newrelic 9.5.0 → 9.7.0

package/lib/instrumentation/@hapi/hapi.js

@@ -5,4 +5,234 @@
 
 'use strict'
 
-module.exports = require('../hapi')
+/* eslint sonarjs/cognitive-complexity: ["error", 68] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
+const record = require('../../metrics/recorders/generic')
+// This object defines all the events that we want to wrap extensions
+// for, as they are the only ones associated with requests.
+const ROUTE_EVENTS = {
+  onRequest: true,
+  onPreAuth: true,
+  onCredentials: true,
+  onPostAuth: true,
+  onPreHandler: true,
+  onPostHandler: true,
+  onPreResponse: true,
+
+  // Server events
+  onPreStart: false,
+  onPostStart: false,
+  onPreStop: false,
+  onPostStop: false
+}
+
+module.exports = function initialize(agent, hapi, moduleName, shim) {
+  if (!agent || !hapi || !shim) {
+    shim &&
+      shim.logger.debug(
+        'Hapi instrumentation function called with incorrect arguments, not instrumenting.'
+      )
+    return false
+  }
+
+  shim.setFramework(shim.HAPI)
+
+  shim.setErrorPredicate(function hapiErrorPredicate(err) {
+    return err instanceof Error
+  })
+
+  // At this point, framework and error predicate have both already been set via ./hapi,
+  // so we only need to set the response predicate and wrap the server object
+  shim.setResponsePredicate(function hapiResponsePredicate(args, result) {
+    return !(result instanceof Error) && result !== args[1].continue
+  })
+
+  // 'Server' and 'server' both point to the same export,
+  // but we can't make any assumption about which will be used.
+  // Since we wrap the prototype, the second wrap should exit early.
+  shim.wrapReturn(hapi, 'server', serverFactoryWrapper)
+  shim.wrapReturn(hapi, 'Server', serverFactoryWrapper)
+}
+
+function serverFactoryWrapper(shim, fn, fnName, server) {
+  serverPostConstructor.call(server, shim)
+}
+
+function serverPostConstructor(shim) {
+  const proto = Object.getPrototypeOf(this)
+
+  if (shim.isWrapped(proto.decorate)) {
+    shim.logger.trace('Already wrapped Server proto, not wrapping again')
+    return
+  }
+
+  shim.wrap(proto, 'decorate', function wrapDecorate(shim, original) {
+    return function wrappedDecorate(type) {
+      // server.decorate also accepts 'request', 'toolkit', 'server' types,
+      // but we're only concerned with 'handler'
+      if (type !== 'handler') {
+        return original.apply(this, arguments)
+      }
+
+      // Convert arguments to usable array
+      const args = shim.argsToArray.apply(shim, arguments)
+
+      // Wrap the third server.decorate arg, the user-defined handler
+      shim.wrap(args, shim.THIRD, function wrapHandler(shim, fn) {
+        if (typeof fn !== 'function') {
+          return
+        }
+
+        if (fn.defaults) {
+          wrappedHandler.defaults = fn.defaults
+        }
+
+        return wrappedHandler
+
+        function wrappedHandler(route) {
+          const ret = fn.apply(this, arguments)
+
+          return typeof ret === 'function' ? wrapRouteHandler(shim, ret, route && route.path) : ret
+        }
+      })
+
+      return original.apply(this, args)
+    }
+  })
+
+  shim.wrap(proto, 'route', function wrapRoute(shim, original) {
+    return function wrappedRoute() {
+      const args = shim.argsToArray.apply(shim, arguments)
+
+      if (!shim.isObject(args[0])) {
+        return original.apply(this, args)
+      }
+
+      // If route is created via a plugin, pull prefix if it exists
+      const prefix =
+        (this.realm &&
+          this.realm.modifiers &&
+          this.realm.modifiers.route &&
+          this.realm.modifiers.route.prefix) ||
+        ''
+
+      _wrapRoute(shim, args[0])
+
+      return original.apply(this, args)
+
+      function _wrapRoute(shim, route) {
+        const routePath = prefix + route.path
+        if (shim.isArray(route)) {
+          for (let i = 0; i < route.length; ++i) {
+            _wrapRoute(shim, route[i])
+          }
+          return
+        } else if (route.options) {
+          // v17 now prefers `options` property...
+          if (route.options.pre) {
+            // config objects can also contain multiple OTHER handlers in a `pre` array
+            route.options.pre = wrapPreHandlers(shim, route.options.pre, routePath)
+          }
+          if (route.options.handler) {
+            _wrapRouteHandler(shim, route.options, routePath)
+            return
+          }
+        } else if (route.config) {
+          // ... but `config` still works
+          if (route.config.pre) {
+            route.config.pre = wrapPreHandlers(shim, route.config.pre, routePath)
+          }
+          if (route.config.handler) {
+            _wrapRouteHandler(shim, route.config, routePath)
+            return
+          }
+        }
+        _wrapRouteHandler(shim, route, routePath)
+      }
+
+      function _wrapRouteHandler(shim, container, path) {
+        if (typeof container.handler !== 'function') {
+          return
+        }
+        shim.wrap(container, 'handler', function wrapHandler(shim, handler) {
+          return wrapRouteHandler(shim, handler, path)
+        })
+      }
+    }
+  })
+
+  shim.wrap(proto, 'ext', function wrapExt(shim, original) {
+    return function wrappedExt(event, method) {
+      const args = shim.argsToArray.apply(shim, arguments)
+
+      if (shim.isArray(event)) {
+        for (let i = 0; i < event.length; i++) {
+          event[i].method = wrapMiddleware(shim, event[i].method, event[i].type)
+        }
+      } else if (shim.isObject(event)) {
+        event.method = wrapMiddleware(shim, event.method, event.type)
+      } else if (shim.isString(event)) {
+        args[1] = wrapMiddleware(shim, method, event)
+      } else {
+        shim.logger.debug('Unsupported event type %j', event)
+        return
+      }
+
+      return original.apply(this, args)
+    }
+  })
+}
+
+function wrapPreHandlers(shim, container, path) {
+  if (shim.isArray(container)) {
+    for (let i = 0; i < container.length; ++i) {
+      container[i] = wrapPreHandlers(shim, container[i], path)
+    }
+    return container
+  } else if (shim.isFunction(container)) {
+    return wrapPreHandler(shim, container, path)
+  } else if (container.method && shim.isFunction(container.method)) {
+    return shim.wrap(container, 'method', function wrapHandler(shim, handler) {
+      return wrapPreHandler(shim, handler, path)
+    })
+  }
+}
+
+function wrapPreHandler(shim, container, path) {
+  return shim.record(container, (shim) => {
+    return { name: [shim.HAPI, ' pre handler: ', '(', path, ')'].join(''), recorder: record }
+  })
+}
+
+function wrapRouteHandler(shim, handler, path) {
+  return shim.recordMiddleware(handler, {
+    route: path,
+    req: function getReq(shim, fn, fnName, args) {
+      const request = args[0]
+      if (request && request.raw) {
+        return request.raw.req
+      }
+    },
+    promise: true,
+    params: function getParams(shim, fn, fnName, args) {
+      const req = args[0]
+      return req && req.params
+    }
+  })
+}
+
+function wrapMiddleware(shim, middleware, event) {
+  if (!ROUTE_EVENTS[event]) {
+    return middleware
+  }
+
+  return shim.recordMiddleware(middleware, {
+    route: event,
+    type: event === 'onPreResponse' ? shim.ERRORWARE : shim.MIDDLEWARE,
+    promise: true,
+    req: function getReq(shim, fn, fnName, args) {
+      const req = args[0]
+      return req && req.raw && req.raw.req
+    }
+  })
+}

package/lib/instrumentation/@node-redis/client.js

@@ -3,6 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/* eslint sonarjs/cognitive-complexity: ["error", 20] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
 'use strict'
 const CLIENT_COMMANDS = ['select', 'quit', 'SELECT', 'QUIT']
 

package/lib/instrumentation/amqplib.js

@@ -5,6 +5,8 @@
 
 'use strict'
 
+/* eslint sonarjs/cognitive-complexity: ["error", 16] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252*/
+
 const url = require('url')
 
 // TODO: Make this an external module.

package/lib/instrumentation/core/async_hooks.js

@@ -5,6 +5,8 @@
 
 'use strict'
 
+/* eslint sonarjs/cognitive-complexity: ["error", 18] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
 const logger = require('../../logger').child({ component: 'async_hooks' })
 const asyncHooks = require('async_hooks')
 
@@ -38,7 +40,7 @@ function initialize(agent, shim) {
 
 function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
   const hooks = {
-    init: function initHook(id, type, triggerId, asyncResource) {
+    init: function initHook(id, type, triggerId) {
       if (type !== 'PROMISE') {
         return
       }
@@ -55,9 +57,6 @@ function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
       }
 
       const activeSegment = shim.getActiveSegment() || parentSegment
-      if (asyncResource && asyncResource.promise) {
-        asyncResource.promise.__NR_id = id
-      }
 
       segmentMap.set(id, activeSegment)
     },

package/lib/instrumentation/core/globals.js

@@ -6,6 +6,7 @@
 'use strict'
 
 const asyncHooks = require('./async_hooks')
+const symbols = require('../../symbols')
 
 module.exports = initialize
 
@@ -37,16 +38,17 @@ function initialize(agent, nodule, name, shim) {
     return function wrappedEmit(ev, error, promise) {
       // Check for unhandledRejections here so we don't change the behavior of
       // the event.
-      if (ev === 'unhandledRejection' && error && !process.domain) {
-        if (process.listenerCount('unhandledRejection') === 0) {
-          // If there are no unhandledRejection handlers report the error.
-          const segment = promise.__NR_id
-            ? asyncHooks.segmentMap.get(promise.__NR_id)
-            : promise.__NR_context && promise.__NR_context.getSegment()
-          const tx = segment && segment.transaction
-          shim.logger.trace('Captured unhandled rejection for transaction %s', tx && tx.id)
-          agent.errors.add(tx, error)
-        }
+      if (
+        ev === 'unhandledRejection' &&
+        error &&
+        !process.domain &&
+        process.listenerCount('unhandledRejection') === 0
+      ) {
+        // If there are no unhandledRejection handlers report the error.
+        const segment = promise[symbols.context] && promise[symbols.context].getSegment()
+        const tx = segment && segment.transaction
+        shim.logger.trace('Captured unhandled rejection for transaction %s', tx && tx.id)
+        agent.errors.add(tx, error)
       }
 
       return original.apply(this, arguments)

package/lib/instrumentation/core/http-outbound.js

@@ -5,6 +5,8 @@
 
 'use strict'
 
+/* eslint sonarjs/cognitive-complexity: ["error", 40] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
 const recordExternal = require('../../metrics/recorders/http_external')
 const cat = require('../../util/cat')
 const urltils = require('../../util/urltils')
@@ -12,9 +14,9 @@ const logger = require('../../logger').child({ component: 'outbound' })
 const shimmer = require('../../shimmer')
 const url = require('url')
 const copy = require('../../util/copy')
+const symbols = require('../../symbols')
 
 const NAMES = require('../../metrics/names')
-const SHIM_SYMBOLS = require('../../shim/constants').SYMBOLS
 
 const DEFAULT_HOST = 'localhost'
 const DEFAULT_HTTP_PORT = 80
@@ -25,10 +27,10 @@ const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
 /**
  * Instruments an outbound HTTP request.
  *
- * @param {Agent} agent
- * @param {object} opts
- * @param {Function} makeRequest
- * @returns {http.ClientRequest} The instrumented outbound request.
+ * @param {object} agent instantiation of lib/agent.js
+ * @param {object} opts HTTP request options
+ * @param {Function} makeRequest function for issuing actual HTTP request
+ * @returns {object} The instrumented outbound HTTP request.
  */
 module.exports = function instrumentOutbound(agent, opts, makeRequest) {
   if (typeof opts === 'string') {
@@ -85,7 +87,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
 
     // TODO: abstract header logic shared with TransactionShim#insertCATRequestHeaders
     if (agent.config.distributed_tracing.enabled) {
-      if (opts.headers && opts.headers[SHIM_SYMBOLS.DISABLE_DT]) {
+      if (opts.headers && opts.headers[symbols.disableDT]) {
         logger.trace('Distributed tracing disabled by instrumentation.')
       } else {
         transaction.insertDistributedTraceHeaders(outboundHeaders)
@@ -113,9 +115,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
     const parsed = urltils.scrubAndParseParameters(request.path)
     const proto = parsed.protocol || opts.protocol || 'http:'
     segment.name += parsed.path
-    Object.defineProperty(request, '__NR_segment', {
-      value: segment
-    })
+    request[symbols.segment] = segment
 
     if (parsed.parameters) {
       // Scrub and parse returns on object with a null prototype.
@@ -153,10 +153,10 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
  * Notices the given error if there is no listener for the `error` event on the
  * request object.
  *
- * @param {TraceSegment} segment
- * @param {http.ClientRequest} req
- * @param {Error} error
- * @returns {bool} True if the error will be collected by New Relic.
+ * @param {object} segment TraceSegment instance
+ * @param {object} req http.ClientRequest
+ * @param {Error} error If provided, unhandled error that occurred during request
+ * @returns {boolean} True if the error will be collected by New Relic.
  */
 function handleError(segment, req, error) {
   if (req.listenerCount('error') > 0) {
@@ -173,10 +173,10 @@ function handleError(segment, req, error) {
 /**
  * Ties the response object to the request segment.
  *
- * @param {TraceSegment} segment
- * @param {string} hostname
- * @param {http.ClientRequest} req
- * @param {http.IncomingMessage} res
+ * @param {object} segment TraceSegment instance
+ * @param {string} hostname host of the HTTP request
+ * @param {object} req http.ClientRequest
+ * @param {object} res http.IncomingMessage
  */
 function handleResponse(segment, hostname, req, res) {
   // Add response attributes for spans

package/lib/instrumentation/core/http.js

@@ -5,6 +5,8 @@
 
 'use strict'
 
+/* eslint sonarjs/cognitive-complexity: ["error", 42] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
 const shimmer = require('../../shimmer')
 const logger = require('../../logger').child({ component: 'http' })
 const recordWeb = require('../../metrics/recorders/http')
@@ -13,21 +15,20 @@ const cat = require('../../util/cat')
 const instrumentOutbound = require('./http-outbound')
 const url = require('url')
 const urltils = require('../../util/urltils')
-const properties = require('../../util/properties')
 const headerAttributes = require('../../header-attributes')
 const headerProcessing = require('../../header-processing')
 
 const NAMES = require('../../metrics/names')
 const DESTS = require('../../config/attribute-filter').DESTINATIONS
 
+const symbols = require('../../symbols')
+
 /*
  *
  * CONSTANTS
  *
  */
-const NR_CONNECTION_PROP = '__NR__connection'
 const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
-const TRANSACTION_INFO_KEY = '__NR_transactionInfo'
 
 // For incoming requests this instrumentation functions by wrapping
 // `http.createServer` and `http.Server#addListener`. The former merely sets the
@@ -55,12 +56,6 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
     // Store the transaction information on the request and response.
     const txInfo = storeTxInfo(transaction, request, response)
 
-    // Hook for web framework instrumentations that don't have easy access to
-    // the request entry point.
-    if (properties.hasOwn(this, '__NR_onRequestStarted')) {
-      this.__NR_onRequestStarted(request, response)
-    }
-
     if (request) {
       initializeRequest(transaction, request)
     }
@@ -204,7 +199,6 @@ function storeTxInfo(transaction, request, response) {
     logger.debug('Missing request or response object! Not storing transaction info.')
     return
   }
-  const hideInternal = transaction.agent.config.transaction_tracer.hide_internals
 
   const txInfo = {
     transaction: transaction,
@@ -212,12 +206,7 @@ function storeTxInfo(transaction, request, response) {
     errorHandled: false,
     error: null
   }
-  if (hideInternal) {
-    properties.setInternal(request, TRANSACTION_INFO_KEY, txInfo)
-    properties.setInternal(response, TRANSACTION_INFO_KEY, txInfo)
-  } else {
-    request[TRANSACTION_INFO_KEY] = response[TRANSACTION_INFO_KEY] = txInfo
-  }
+  request[symbols.transactionInfo] = response[symbols.transactionInfo] = txInfo
 
   logger.trace('Stored transaction %s information on request and response', transaction.id)
 
@@ -245,7 +234,7 @@ function wrapResponseEnd(agent, proto) {
     }
 
     return function wrappedResEnd() {
-      const txInfo = this && this[TRANSACTION_INFO_KEY]
+      const txInfo = this && this[symbols.transactionInfo]
       if (!txInfo) {
         return end.apply(this, arguments)
       }
@@ -256,10 +245,11 @@ function wrapResponseEnd(agent, proto) {
       }
 
       // If an error happened, add it to the aggregator.
-      if (txInfo.error) {
-        if (!txInfo.errorHandled || urltils.isError(agent.config, this.statusCode)) {
-          agent.errors.add(txInfo.transaction, txInfo.error)
-        }
+      if (
+        txInfo.error &&
+        (!txInfo.errorHandled || urltils.isError(agent.config, this.statusCode))
+      ) {
+        agent.errors.add(txInfo.transaction, txInfo.error)
       }
 
       // End all the segments leading up to and including this one.
@@ -393,9 +383,9 @@ function wrapRequest(agent, request) {
     const reqArgs = [options, cb]
 
     // Don't pollute metrics and calls with NR connections
-    const internalOnly = options && options[NR_CONNECTION_PROP]
+    const internalOnly = options && options[symbols.offTheRecord]
     if (internalOnly) {
-      delete options[NR_CONNECTION_PROP]
+      delete options[symbols.offTheRecord]
     }
 
     // If this is not a request we're recording, exit early.
@@ -492,8 +482,7 @@ module.exports = function initialize(agent, http, moduleName) {
           args[1] = agent.tracer.bindFunction(args[1], segment, true)
         }
 
-        const sock = agent.tracer.bindFunction(original, segment, true).apply(this, args)
-        return sock
+        return agent.tracer.bindFunction(original, segment, true).apply(this, args)
       }
     }
   )
@@ -507,7 +496,7 @@ module.exports = function initialize(agent, http, moduleName) {
  * @param {string} header - The raw X-NewRelic-Synthetics header
  * @param {string} encKey - Encoding key handed down from the server
  * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
- * @param {Transaction} transaction - Where the synthetics data is attached to.
+ * @param {object} transaction - Where the synthetics data is attached to.
  */
 function handleSyntheticsHeader(header, encKey, trustedIds, transaction) {
   const synthData = parseSyntheticsHeader(header, encKey, trustedIds)
@@ -525,7 +514,7 @@ function handleSyntheticsHeader(header, encKey, trustedIds, transaction) {
  * @param {string} header - The raw X-NewRelic-Synthetics header
  * @param {string} encKey - Encoding key handed down from the server
  * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
- * @return {Object|null} - On successful parse and verification an object of
+ * @returns {object | null} - On successful parse and verification an object of
  *                            synthetics data is returned, otherwise null is
  *                            returned.
  */

package/lib/instrumentation/core/timers.js

@@ -5,6 +5,10 @@
 
 'use strict'
 
+/* eslint sonarjs/cognitive-complexity: ["error", 16] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
+const symbols = require('../../symbols')
+
 module.exports = initialize
 
 function initialize(agent, timers, moduleName, shim) {
@@ -53,7 +57,7 @@ function initialize(agent, timers, moduleName, shim) {
   function wrapClearTimeout(shim, fn) {
     return function wrappedClearTimeout(timer) {
       if (timer && timer._onTimeout) {
-        const segment = timer._onTimeout.__NR_segment
+        const segment = timer._onTimeout[symbols.segment]
         if (segment && !segment.opaque) {
           segment.ignore = true
         }

package/lib/instrumentation/fastify.js

@@ -148,9 +148,7 @@ function wrapMiddleware(shim, middleware, name, route) {
   const segmentName = `onRequest/${name}`
   const spec = buildMiddlewareSpecForMiddlewareFunction(shim, segmentName, route)
 
-  const newMiddlewareFunction = shim.recordMiddleware(middleware, spec)
-
-  return newMiddlewareFunction
+  return shim.recordMiddleware(middleware, spec)
 }
 
 /**

package/lib/instrumentation/grpc-js/grpc.js

@@ -78,8 +78,10 @@ function wrapStart(shim, original) {
         segment.addAttribute('grpc.statusCode', code)
         segment.addAttribute('grpc.statusText', details)
 
-        if (code !== 0 && shim.agent.config.grpc.record_errors) {
-          // this is currently just creating an error from the details string
+        const agent = shim.agent
+        const config = agent.config
+
+        if (shouldTrackError(code, config)) {
           shim.agent.errors.add(segment.transaction, details)
         }
 
@@ -184,9 +186,10 @@ function wrapRegister(shim, original) {
 
     function instrumentEventListeners(stream, transaction) {
       const agent = shim.agent
+      const config = agent.config
       stream.call.once('callEnd', (statusCode) => {
         transaction.trace.attributes.addAttribute(DESTINATION, 'response.status', statusCode)
-        if (statusCode !== 0 && agent.config.grpc.record_errors) {
+        if (shouldTrackError(statusCode, config)) {
           const status = constants.Status[statusCode]
           const error = new Error(`gRPC status code ${statusCode}: ${status}`)
           agent.errors.add(transaction, error)
@@ -202,6 +205,14 @@ function wrapRegister(shim, original) {
   }
 }
 
+function shouldTrackError(statusCode, config) {
+  return (
+    statusCode > 0 &&
+    config.grpc.record_errors &&
+    !config.grpc.ignore_status_codes.includes(statusCode)
+  )
+}
+
 module.exports = function instrument(shim) {
   const genericShim = shim.makeSpecializedShim(shim.GENERIC, 'call-stream')
   const callStream = genericShim.require('./build/src/call-stream')

package/lib/instrumentation/memcached.js

@@ -21,6 +21,11 @@ function wrapKeys(metacall) {
  * Thanks to Hernan Silberman!
  *
  * instrument the memcached driver to intercept calls and keep stats on them.
+ *
+ * @param agent
+ * @param memcached
+ * @param moduleName
+ * @param shim
  */
 module.exports = function initialize(agent, memcached, moduleName, shim) {
   const proto = memcached && memcached.prototype

package/lib/instrumentation/mongodb/common.js

@@ -4,6 +4,9 @@
  */
 
 'use strict'
+
+/* eslint sonarjs/cognitive-complexity: ["error", 18] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
 const { CURSOR_OPS, COLLECTION_OPS, DB_OPS } = require('./constants')
 const common = module.exports
 common.NR_ATTRS = Symbol('NR_ATTRS')

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

@@ -11,7 +11,7 @@ const { captureAttributesOnStarted, makeQueryDescFunc } = require('./common')
  * parser used to grab the collection and operation
  * from a running query
  *
- * @param {Object} operation
+ * @param {object} operation
  */
 function queryParser(operation) {
   let collection = this.collectionName || 'unknown'
@@ -29,7 +29,7 @@ function queryParser(operation) {
  * add necessary attributes to segments
  *
  * @param {Shim} shim
- * @param {Object} mongodb resolved package
+ * @param {object} mongodb resolved package
  */
 module.exports = function instrument(shim, mongodb) {
   shim.setParser(queryParser)
@@ -65,6 +65,9 @@ module.exports = function instrument(shim, mongodb) {
    * Iterate over permutations and properly
    * wrap depending on the `recordDesc` above
    * See: https://github.com/mongodb/node-mongodb-native/blob/v3.0.5/lib/collection.js#L384
+   *
+   * @param _
+   * @param modules
    */
   function instrumentModules(_, modules) {
     modules.forEach((module) => {
@@ -80,7 +83,7 @@ module.exports = function instrument(shim, mongodb) {
    * if it needs to be wrapped as an operation or query
    *
    * @param {string} objectName name of class getting instrumented
-   * @param {Object} object reference to the class getting instrumented
+   * @param {object} object reference to the class getting instrumented
    * @param {Define} meta describes the methods and if they are callbacks
    * promises, and return values
    */

package/lib/instrumentation/mongodb.js

@@ -25,7 +25,7 @@ module.exports = initialize
  * based on version of mongodb
  *
  * @param {Agent} agent
- * @param {Object} mongodb resolved package
+ * @param {object} mongodb resolved package
  * @param {string} moduleName name of module
  * @param {Shim} shim
  */