newrelic 4.7.0 → 4.8.0

package/NEWS.md

@@ -1,3 +1,24 @@
+### 4.8.0 (2018-08-13):
+
+* Added JSON-formatted output to benchmarks to enable automated benchmark comparison.
+
+* Updated the benchmark runner to measure specifically userland CPU overhead.
+
+* Added DatastoreShim benchmarks.
+
+* Fixed MongoDB instrumentation for driver versions greater than 3.0.6.
+
+  Mongo 3.0.6 removed metadata the Agent relied upon to instrument the driver. This
+  fixes that by going back to the old method of manually listing all objects and
+  methods to instrument.
+
+* Implemented enforcement of `max_payload_size_in_bytes` config value.
+
+  Any payload during the harvest sequence that exceeds the configured limit will
+  be discarded.
+
+* Updated MySQL versioned tests to run against the latest release.
+
 ### 4.7.0 (2018-07-31):
 
 * Added support for distributed tracing.

package/bin/compare-bench-results.js

@@ -0,0 +1,159 @@
+'use strict'
+/* eslint-disable no-console */
+
+const async = require('async')
+const fs = require('fs')
+
+if (process.argv.length !== 4) {
+  console.log('Usage: %s %s <baseline> <upstream>', process.argv[0], process.argv[1])
+  console.log('  <baseline>   JSON file containing benchmark results for upstream')
+  console.log('               upstream comparison.')
+  console.log('  <downstream> JSON file containing benchmark results from')
+  console.log('               downstream branch to compare against base.')
+  process.exit(1)
+}
+
+async.map(process.argv.slice(2), (file, cb) => {
+  fs.readFile(file, {encoding: 'utf8'}, (err, data) => {
+    if (err) {
+      return cb(err)
+    }
+
+    let parsed = null
+    try {
+      parsed = JSON.parse(data)
+    } catch (parseError) {
+      return cb(parseError)
+    }
+
+    cb(null, parsed)
+  })
+}, (err, resultFiles) => {
+  if (err) {
+    console.log('Failed to load files.')
+    console.log(err)
+    process.exit(2)
+  }
+
+  const baseline = resultFiles[0]
+  const downstream = resultFiles[1]
+
+  const baselineFiles = Object.keys(baseline)
+  const downstreamFiles = Object.keys(downstream)
+  const warnings = []
+
+  diffArrays(baselineFiles, downstreamFiles).forEach((file) => {
+    warnings.push(`- **WARNING**: File "${file}" in base but not branch.`)
+  })
+  diffArrays(downstreamFiles, baselineFiles).forEach((file) => {
+    warnings.push(`- **NOTE**: File "${file}" in branch but not base.`)
+  })
+
+  let allPassing = true
+  const details = baselineFiles.sort().map((testFile) => {
+    const base = baseline[testFile]
+    const down = downstream[testFile]
+
+    if (!down) {
+      return [
+        '<details>',
+        `<summary>${testFile} file missing from branch</summary>`,
+        '',
+        '</details>'
+      ].join('\n')
+    }
+
+    let filePassing = true
+    const baseTests = Object.keys(base)
+    const downTests = Object.keys(down)
+
+    diffArrays(baseTests, downTests).forEach((test) => {
+      warnings.push(`- **WARNING**: Test "${test}" in base but not branch.`)
+    })
+    diffArrays(downTests, baseTests).forEach((test) => {
+      warnings.push(`- **NOTE**: Test "${test}" in branch but not base.`)
+    })
+
+    const results = baseTests.sort().map((test) => {
+      const passes = compareResults(base[test], down[test])
+      filePassing = filePassing && passes
+
+      return [
+        '<details>',
+        `<summary>${test}: ${passMark(passes)}</summary>`,
+        '',
+        formatResults(base[test], down[test]),
+        '</details>',
+        ''
+      ].join('\n')
+    }).join('\n')
+    allPassing = allPassing && filePassing
+
+    return [
+      '<details>',
+      `<summary>${testFile}: ${passMark(filePassing)}</summary>`,
+      '',
+      results,
+      '</details>'
+    ].join('\n')
+  }).join('\n\n-----------------------------------------------------------\n\n')
+
+  if (warnings.length) {
+    console.log('### WARNINGS')
+    console.log(warnings.join('\n'))
+    console.log('')
+  }
+
+  console.log(`### Benchmark Results: ${passMark(allPassing)}`)
+  console.log('')
+  console.log('### Details')
+  console.log(details)
+
+  if (!allPassing) {
+    process.exitCode = -1
+  }
+})
+
+function diffArrays(a, b) {
+  return a.filter((elem) => !b.includes(elem))
+}
+
+function compareResults(base, down) {
+  const delta = base.mean - down.mean
+  const deltaPercent = delta / base.mean
+  return delta < 1 || deltaPercent < 2
+}
+
+function passMark(passes) {
+  return passes ? '✔' : '✘'
+}
+
+function formatResults(base, down) {
+  return [
+    `- ${formatField('numSamples', base, down)}`,
+    `- ${formatField('mean', base, down)}`,
+    `- ${formatField('stdDev', base, down)}`,
+    `- ${formatField('max', base, down)}`,
+    `- ${formatField('min', base, down)}`,
+    `- ${formatField('5thPercentile', base, down)}`,
+    `- ${formatField('95thPercentile', base, down)}`,
+    `- ${formatField('median', base, down)}`,
+  ].join('\n')
+}
+
+function formatField(field, base, down) {
+  const baseValue = base[field]
+  const downValue = down[field]
+  const diffValue = baseValue - downValue
+  const diffPercent = (100 * diffValue / baseValue).toFixed(2)
+  const prefix = diffValue >= 0 ? '+' : ''
+
+  return (
+    `${field}: ${fixValue(baseValue)} - ${fixValue(downValue)} =` +
+    ` ${fixValue(diffValue)} (${prefix}${diffPercent}%)`
+  )
+}
+
+function fixValue(value) {
+  return value % 1 ? value.toFixed(5) : value
+}

package/bin/run-bench.js

@@ -36,54 +36,97 @@ if (tests.length === 0 && globs.length === 0) {
   )
 }
 
-a.series([
-  function resolveGlobs(cb) {
-    if (!globs.length) {
-      return cb()
-    }
+class ConsolePrinter {
+  /* eslint-disable no-console */
+  addTest(name, child) {
+    console.log(name)
+    child.stdout.on('data', (d) => process.stdout.write(d))
+    child.stderr.on('data', (d) => process.stderr.write(d))
+    child.once('exit', () => console.log(''))
+  }
+
+  finish() {
+    console.log('')
+  }
+  /* eslint-enable no-console */
+}
+
+class JSONPrinter {
+  constructor() {
+    this._tests = Object.create(null)
+  }
+
+  addTest(name, child) {
+    let output = ''
+    this._tests[name] = null
+    child.stdout.on('data', (d) => output += d.toString())
+    child.stdout.on('end', () => this._tests[name] = JSON.parse(output))
+    child.stderr.on('data', (d) => process.stderr.write(d))
+  }
+
+  finish() {
+    /* eslint-disable no-console */
+    console.log(JSON.stringify(this._tests, null, 2))
+    /* eslint-enable no-console */
+  }
+}
+
+run()
+
+function run() {
+  const printer = opts.json ? new JSONPrinter() : new ConsolePrinter()
 
-    a.map(globs, glob, function afterGlobbing(err, resolved) {
-      if (err) {
-        console.error('Failed to glob:', err)
-        process.exitCode = -1
-        return cb(err)
+  a.series([
+    function resolveGlobs(cb) {
+      if (!globs.length) {
+        return cb()
       }
-      resolved.forEach(function mergeResolved(files) {
-        files.forEach(function mergeFile(file) {
-          if (tests.indexOf(file) === -1) {
-            tests.push(file)
-          }
+
+      a.map(globs, glob, function afterGlobbing(err, resolved) {
+        if (err) {
+          console.error('Failed to glob:', err)
+          process.exitCode = -1
+          return cb(err)
+        }
+        resolved.forEach(function mergeResolved(files) {
+          files.forEach(function mergeFile(file) {
+            if (tests.indexOf(file) === -1) {
+              tests.push(file)
+            }
+          })
         })
+        cb()
       })
-      cb()
-    })
-  },
-  function runBenchmarks(cb) {
-    tests.sort()
-    a.eachSeries(tests, function spawnEachFile(file, cb) {
-      var test = path.relative(benchpath, file)
-
-      console.log(test)
-      var args = ['--expose-gc', file]
-      if (opts.inspect) {
-        args.unshift('--inspect-brk')
-      }
-      var child = cp.spawn('node', args, {cwd: cwd, stdio: 'inherit'})
-      child.on('error', cb)
-      child.on('exit', function onChildExit(code) {
-        console.log('')
-        if (code) {
-          return cb(new Error('Benchmark exited with code ' + code))
+    },
+    function runBenchmarks(cb) {
+      tests.sort()
+      a.eachSeries(tests, function spawnEachFile(file, cb) {
+        var test = path.relative(benchpath, file)
+
+        var args = [file]
+        if (opts.inspect) {
+          args.unshift('--inspect-brk')
+        }
+        var child = cp.spawn('node', args, {cwd: cwd, stdio: 'pipe'})
+        printer.addTest(test, child)
+
+        child.on('error', cb)
+        child.on('exit', function onChildExit(code) {
+          if (code) {
+            return cb(new Error('Benchmark exited with code ' + code))
+          }
+          cb()
+        })
+      }, function afterSpawnEachFile(err) {
+        if (err) {
+          console.error('Spawning failed:', err)
+          process.exitCode = -2
+          return cb(err)
         }
         cb()
       })
-    }, function afterSpawnEachFile(err) {
-      if (err) {
-        console.error('Spawning failed:', err)
-        process.exitCode = -2
-        return cb(err)
-      }
-      cb()
-    })
-  }
-])
+    }
+  ], () => {
+    printer.finish()
+  })
+}

package/lib/collector/remote-method.js

@@ -10,6 +10,7 @@ var stringify = require('json-stringify-safe')
 var Sink = require('../util/stream-sink')
 var agents = require('./http-agents')
 var certificates = require('./ssl/certificates')
+const isValidLength = require('../util/byte-limit').isValidLength
 
 /*
  *
@@ -147,8 +148,19 @@ RemoteMethod.prototype._safeRequest = function _safeRequest(options) {
   var protocol = 'https'
   var logConfig = this._config.logging
   var auditLog = this._config.audit_log
+  const maxPayloadSize = this._config.max_payload_size_in_bytes
   var level = 'trace'
 
+  if (!isValidLength(options.body, maxPayloadSize + 1)) {
+    logger.warn(
+      'The payload size %d being sent to method %s exceeded the maximum size of %d',
+      Buffer.byteLength(options.body, 'utf8'),
+      this.name,
+      maxPayloadSize
+    )
+    throw new Error('Maximum payload size exceeded')
+  }
+
   // If trace level is not explicity enabled check to see if the audit log is
   // enabled.
   if (logConfig != null && logConfig.level !== 'trace' && auditLog.enabled) {

package/lib/config/index.js

@@ -21,6 +21,7 @@ var logger = null // Lazy-loaded in `initialize`.
 /**
  * CONSTANTS -- we gotta lotta 'em
  */
+const DEFAULT_MAX_PAYLOAD_SIZE_IN_BYTES = 1000000
 const DEFAULT_CONFIG_PATH = require.resolve('./default')
 const DEFAULT_CONFIG = require('./default').config
 const DEFAULT_FILENAME = 'newrelic.js'
@@ -126,6 +127,7 @@ function Config(config) {
   this.trusted_account_key = null
   this.sampling_target = 10
   this.sampling_target_period_in_seconds = 60
+  this.max_payload_size_in_bytes = DEFAULT_MAX_PAYLOAD_SIZE_IN_BYTES
 
   // how frequently harvester runs
   this.data_report_period = 60
@@ -273,6 +275,7 @@ Config.prototype._fromServer = function _fromServer(params, key) {
     case 'collect_errors':
     case 'collect_traces':
     case 'product_level':
+    case 'max_payload_size_in_bytes':
     case 'sampling_target':
     case 'sampling_target_period_in_seconds':
     case 'trusted_account_ids':

package/lib/instrumentation/mongodb.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const semver = require('semver')
+
 // XXX: When this instrumentation is modularized, update this thread
 // with a cautionary note:
 // https://discuss.newrelic.com/t/feature-idea-using-mongoose-cursors-memory-leaking-very-quickly/49270/14
@@ -9,7 +11,7 @@
 // location.
 
 // legacy endpoint enumerations
-var DB_OPS = [
+const DB_OPS = [
   'addUser',
   'authenticate',
   'collection',
@@ -37,7 +39,7 @@ var DB_OPS = [
   '_executeQueryCommand'
 ]
 
-var COLLECTION_OPS = [
+const COLLECTION_OPS = [
   'aggregate',
   'bulkWrite',
   'count',
@@ -79,13 +81,13 @@ var COLLECTION_OPS = [
   'updateOne'
 ]
 
-var GRID_OPS = [
+const GRID_OPS = [
   'put',
   'get',
   'delete'
 ]
 
-var CURSOR_OPS = [
+const CURSOR_OPS = [
   'nextObject',
   'next',
   'toArray',
@@ -97,24 +99,10 @@ module.exports = initialize
 
 function initialize(agent, mongodb, moduleName, shim) {
   if (!mongodb) return
-  var recordDesc = {
-    'Gridstore': {isQuery: false, makeDesc: function makeGridDesc(opName) {
-      return {name:'GridFS-' + opName, callback: shim.LAST}
-    }},
-    'OrderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'UnorderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'CommandCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'AggregationCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'Cursor': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'Collection': {isQuery: true, makeDesc: makeQueryDescFunc},
-    'Db': {isQuery: false, makeDesc: function makeDbDesc() {
-      return {callback: shim.LAST}
-    }}
-  }
 
   shim.setDatastore(shim.MONGODB)
   shim.setParser(function mongoQueryParser(operation) {
-    var collection = this.collectionName || 'unknown'
+    let collection = this.collectionName || 'unknown'
     if (this.collection && this.collection.collectionName) {
       collection = this.collection.collectionName
     } else if (this.s && this.s.name) {
@@ -123,36 +111,51 @@ function initialize(agent, mongodb, moduleName, shim) {
       collection = this.ns.split(/\./)[1] || collection
     }
 
-    return {
-      operation: operation,
-      collection: collection
-    }
+    return {operation, collection}
   })
 
-  // instrument using the apm api
-  if (mongodb.instrument) {
-    var instrumenter = mongodb.instrument(Object.create(null), instrumentModules)
-    instrumenter.on('started', function onMongoEventStarted(evnt) {
-      // This assumes that this `started` event is fired _after_ our wrapper
-      // starts and creates the segment. We perform a check of the segment name
-      // out of an excess of caution.
-      var 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 (connId.domainSocket) {
-          shim.captureInstanceAttributes('localhost', connId.host, evnt.databaseName)
-        } else {
-          shim.captureInstanceAttributes(connId.host, connId.port, evnt.databaseName)
-        }
-      }
-    })
+  const mongoVersion = shim.require('./package.json').version
+  if (semver.satisfies(mongoVersion, '>=3.0.6') && mongodb.instrument) {
+    instrument306(shim, mongodb)
+  } else if (mongodb.instrument) {
+    instrumentInstrument(shim, mongodb)
   } else {
-    // fallback to legacy enumerations
-    legacyInstrumentation()
+    instrumentLegacy(shim, mongodb)
+  }
+}
+
+function instrument306(shim, mongodb) {
+  const instrumenter = mongodb.instrument(Object.create(null), () => {})
+  captureAttributesOnStarted(shim, instrumenter)
+  instrumentLegacy(shim, mongodb)
+
+  if (shim.isFunction(instrumenter.uninstrument)) {
+    shim.agent.once('unload', function uninstrumentMongo() {
+      instrumenter.uninstrument()
+    })
+  }
+}
+
+function instrumentInstrument(shim, mongodb) {
+  const recordDesc = {
+    'Gridstore': {isQuery: false, makeDesc: function makeGridDesc(opName) {
+      return {name:'GridFS-' + opName, callback: shim.LAST}
+    }},
+    'OrderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'UnorderedBulkOperation': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'CommandCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'AggregationCursor': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'Cursor': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'Collection': {isQuery: true, makeDesc: makeQueryDescFunc},
+    'Db': {isQuery: false, makeDesc: function makeDbDesc() {
+      return {callback: shim.LAST}
+    }}
   }
 
+  // instrument using the apm api
+  const instrumenter = mongodb.instrument(Object.create(null), instrumentModules)
+  captureAttributesOnStarted(shim, instrumenter)
+
   function instrumentModules(err, instrumentations) {
     if (err) {
       shim.logger
@@ -182,9 +185,9 @@ function initialize(agent, mongodb, moduleName, shim) {
         var makeDescFunc = recordDesc[objectName].makeDesc
         var proto = object.prototype
         if (isQuery) {
-          shim.recordQuery(proto, method, makeDescFunc(method))
+          shim.recordQuery(proto, method, makeDescFunc(shim, method))
         } else if (isQuery === false) { // could be unset
-          shim.recordOperation(proto, method, makeDescFunc(method))
+          shim.recordOperation(proto, method, makeDescFunc(shim, method))
         } else {
           shim.logger.trace('No wrapping method found for %s', objectName)
         }
@@ -197,95 +200,135 @@ function initialize(agent, mongodb, moduleName, shim) {
       shim.recordOperation(object.prototype, 'pipe')
     }
   }
+}
 
-  function makeQueryDescFunc(methodName) {
-    return function queryDescFunc() {
-      var parameters = getInstanceAttributeParameters(this)
-      var callback = shim.LAST
-      if (methodName === 'each') {
-        return {query: methodName, parameters: parameters, rowCallback: callback}
+function captureAttributesOnStarted(shim, instrumenter) {
+  instrumenter.on('started', function onMongoEventStarted(evnt) {
+    // This assumes that this `started` event is fired _after_ our wrapper
+    // starts and creates the segment. We perform a check of the segment name
+    // 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)
+        }
+      } else if (connId.domainSocket) {
+        shim.captureInstanceAttributes('localhost', connId.host, evnt.databaseName)
+      } else {
+        shim.captureInstanceAttributes(connId.host, connId.port, evnt.databaseName)
       }
-
-      // segment name does not actually use query string
-      // method name is set as query so the query parser has access to the op name
-      return {query: methodName, callback: callback, parameters: parameters}
     }
-  }
+  })
+}
 
-  function getInstanceAttributeParameters(obj) {
-    if (obj.db && obj.db.serverConfig) {
-      shim.logger.trace('Adding datastore instance attributes from obj.db.serverConfig')
-      var serverConfig = obj.db.serverConfig
-      var db = serverConfig.db || serverConfig.dbInstance
-      return doCapture(serverConfig, db && db.databaseName)
-    } else if (obj.s && obj.s.db && obj.s.topology) {
-      shim.logger.trace(
-        'Adding datastore instance attributes from obj.s.db + obj.s.topology'
+function instrumentLegacy(shim, mongodb) {
+  instrumentCursor(mongodb.Cursor)
+  instrumentCursor(shim.require('./lib/aggregation_cursor'))
+  instrumentCursor(shim.require('./lib/command_cursor'))
+
+  if (mongodb.Collection && mongodb.Collection.prototype) {
+    const proto = mongodb.Collection.prototype
+    for (let i = 0; i < COLLECTION_OPS.length; i++) {
+      shim.recordQuery(
+        proto,
+        COLLECTION_OPS[i],
+        makeQueryDescFunc(shim, COLLECTION_OPS[i])
       )
-      var databaseName = obj.s.db.databaseName || null
-      var topology = obj.s.topology
-      if (topology.s && topology.s.options) {
-        return doCapture(topology.s.options, databaseName)
-      }
     }
+  }
 
-    shim.logger.trace('Could not find datastore instance attributes.')
-    return {
-      host: null,
-      port_path_or_id: null,
-      database_name: null
+  if (mongodb.Grid && mongodb.Grid.prototype) {
+    const proto = mongodb.Grid.prototype
+    for (let i = 0; i < CURSOR_OPS.length; i++) {
+      shim.recordOperation(proto, GRID_OPS[i],
+        {name:'GridFS-' + GRID_OPS[i], callback: shim.LAST})
     }
+  }
 
-    function doCapture(conf, database) {
-      var host = conf.host
-      var 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)
-      ) {
-        port = host
-        host = 'localhost'
-      }
+  if (mongodb.Db && mongodb.Db.prototype) {
+    const proto = mongodb.Db.prototype
+    shim.recordOperation(proto, DB_OPS, {callback: shim.LAST})
+    shim.recordOperation(mongodb.Db, 'connect', {callback: shim.LAST})
+  }
 
-      return {
-        host: host,
-        port_path_or_id: port,
-        database_name: database
+  function instrumentCursor(Cursor) {
+    if (Cursor && Cursor.prototype) {
+      const proto = Cursor.prototype
+      for (let i = 0; i < CURSOR_OPS.length; i++) {
+        shim.recordQuery(proto, CURSOR_OPS[i], makeQueryDescFunc(shim, CURSOR_OPS[i]))
       }
+
+      shim.recordQuery(proto, 'each', makeQueryDescFunc(shim, 'each'))
+      shim.recordOperation(proto, 'pipe')
     }
   }
+}
 
-  function legacyInstrumentation() {
-    if (mongodb.Cursor && mongodb.Cursor.prototype) {
-      var proto = mongodb.Cursor.prototype
-      for (var i = 0; i < CURSOR_OPS.length; i++) {
-        shim.recordQuery(proto, CURSOR_OPS[i], makeQueryDescFunc(CURSOR_OPS[i]))
-      }
-
-      shim.recordQuery(proto, 'each', makeQueryDescFunc('each'))
+function makeQueryDescFunc(shim, methodName) {
+  if (methodName === 'each') {
+    return function eachDescFunc() {
+      const parameters = getInstanceAttributeParameters(shim, this)
+      return {query: methodName, parameters, rowCallback: shim.LAST}
     }
+  }
 
-    if (mongodb.Collection && mongodb.Collection.prototype) {
-      var proto = mongodb.Collection.prototype
-      for (var i = 0; i < COLLECTION_OPS.length; i++) {
-        shim.recordQuery(proto, COLLECTION_OPS[i], makeQueryDescFunc(COLLECTION_OPS[i]))
-      }
+  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 {query: methodName, parameters, callback: shim.LAST}
+  }
+}
+
+function getInstanceAttributeParameters(shim, obj) {
+  if (obj.db && obj.db.serverConfig) {
+    shim.logger.trace('Adding datastore instance attributes from obj.db.serverConfig')
+    const serverConfig = obj.db.serverConfig
+    const db = serverConfig.db || serverConfig.dbInstance
+    return doCapture(serverConfig, db && db.databaseName)
+  } else if (obj.s && obj.s.db && obj.s.topology) {
+    shim.logger.trace(
+      'Adding datastore instance attributes from obj.s.db + obj.s.topology'
+    )
+    const databaseName = obj.s.db.databaseName || null
+    const topology = obj.s.topology
+    if (topology.s && topology.s.options) {
+      return doCapture(topology.s.options, databaseName)
     }
+  }
 
-    if (mongodb.Grid && mongodb.Grid.prototype) {
-      var proto = mongodb.Grid.prototype
-      for (var i = 0; i < CURSOR_OPS.length; i++) {
-        shim.recordOperation(proto, GRID_OPS[i],
-          {name:'GridFS-' + GRID_OPS[i], callback: shim.LAST})
-      }
+  shim.logger.trace('Could not find datastore instance attributes.')
+  return {
+    host: null,
+    port_path_or_id: null,
+    database_name: null
+  }
+
+  function doCapture(conf, database) {
+    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)
+    ) {
+      port = host
+      host = 'localhost'
     }
 
-    if (mongodb.Db && mongodb.Db.prototype) {
-      var proto = mongodb.Db.prototype
-      shim.recordOperation(proto, DB_OPS, {callback: shim.LAST})
-      shim.recordOperation(mongodb.Db, 'connect', {callback: shim.LAST})
+    return {
+      host: host,
+      port_path_or_id: port,
+      database_name: database
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "4.7.0",
+  "version": "4.8.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "licenses": [
     {
@@ -105,6 +105,7 @@
   "scripts": {
     "bench": "node ./bin/run-bench.js",
     "versioned-tests": "./bin/run-versioned-tests.sh",
+    "versioned": "./bin/run-versioned-tests.sh",
     "test": "make test"
   },
   "bin": {