newrelic 8.3.0 → 8.5.2

package/lib/shim/datastore-shim.js

@@ -345,7 +345,7 @@ function setDatastore(datastore) {
  */
 function setParser(parser) {
   if (this.isString(parser)) {
-    var newParser = defaultParsers[parser]
+    const newParser = defaultParsers[parser]
     if (newParser) {
       this.queryParser = newParser
     } else {
@@ -407,7 +407,7 @@ function recordOperation(nodule, properties, opSpec) {
     shim.logger.trace('Recording datastore operation "%s"', fnName)
 
     // Derive the segment information.
-    var segDesc = null
+    let segDesc = null
     if (shim.isFunction(opSpec)) {
       segDesc = opSpec.call(this, shim, fn, fnName, args)
     } else {
@@ -531,9 +531,9 @@ function recordBatchQuery(nodule, properties, querySpec) {
  * @see DatastoreShim#setParser
  */
 function parseQuery(query, nodule) {
-  var parsed = this.queryParser.call(nodule, query)
+  const parsed = this.queryParser.call(nodule, query)
 
-  var collection = parsed.collection
+  let collection = parsed.collection
   // strip enclosing special characters from collection (table) name
   if (typeof collection === 'string' && collection.length > 2) {
     if (/^[\[{'"`]/.test(collection)) {
@@ -544,7 +544,7 @@ function parseQuery(query, nodule) {
     }
   }
 
-  var queryRecorded =
+  const queryRecorded =
     this.agent.config.transaction_tracer.record_sql === 'raw' ||
     this.agent.config.transaction_tracer.record_sql === 'obfuscated'
 
@@ -574,14 +574,14 @@ function parseQuery(query, nodule) {
  *  the segment active when the row callback is first called.
  */
 function bindRowCallbackSegment(args, cbIdx, parentSegment) {
-  var idx = this.normalizeIndex(args.length, cbIdx)
+  const idx = this.normalizeIndex(args.length, cbIdx)
   if (idx === null) {
     this.logger.debug('Not binding row callback, invalid cbIdx %s', cbIdx)
     return
   }
 
   // Pull out the callback and make sure it is a function.
-  var cb = args[idx]
+  const cb = args[idx]
   if (!this.isFunction(cb)) {
     this.logger.debug('Argument %d is not a function, not binding row callback', cbIdx)
     return cb
@@ -589,16 +589,16 @@ function bindRowCallbackSegment(args, cbIdx, parentSegment) {
   this.logger.trace('Wrapping argument %d as a row callback.', cbIdx)
 
   // We have a little state to maintain through potentially multiple calls.
-  var callCounter = 0
-  var segment = null
-  var segmentName = 'Callback: ' + this.getName(cb)
-  var shim = this
+  let callCounter = 0
+  let segment = null
+  const segmentName = 'Callback: ' + this.getName(cb)
+  const shim = this
 
-  var wrapper = this.bindSegment(function rowCallbackWrapper() {
+  const wrapper = this.bindSegment(function rowCallbackWrapper() {
     // The first time this row callback is fired we want to touch the parent
     // segment and create the callback segment.
     if (++callCounter === 1) {
-      var realParent = parentSegment || shim.getSegment()
+      const realParent = parentSegment || shim.getSegment()
       realParent && realParent.touch()
       segment = shim.createSegment(segmentName, realParent)
 
@@ -633,7 +633,7 @@ function bindRowCallbackSegment(args, cbIdx, parentSegment) {
  */
 function captureInstanceAttributes(host, port, database) {
   // See if we are currently in a segment created by us.
-  var segment = this.getSegment()
+  const segment = this.getSegment()
   if (!segment || segment.shim !== this) {
     this.logger.trace(
       'Not adding db instance metric attributes to segment %j',
@@ -644,13 +644,13 @@ function captureInstanceAttributes(host, port, database) {
   this.logger.trace('Adding db instance attributes to segment %j', segment.name)
 
   // Normalize the instance attributes.
-  var attributes = _normalizeParameters.call(this, {
+  const attributes = _normalizeParameters.call(this, {
     host,
     port_path_or_id: port,
     database_name: database
   })
 
-  for (let key in attributes) {
+  for (const key in attributes) {
     if (attributes[key]) {
       segment.addAttribute(key, attributes[key])
     }
@@ -720,7 +720,7 @@ function _recordQuery(suffix, nodule, properties, querySpec) {
   return this.record(nodule, properties, function queryRecord(shim, fn, fnName, args) {
     shim.logger.trace('Determining query information for %j', fnName)
 
-    var queryDesc = querySpec
+    let queryDesc = querySpec
     if (shim.isFunction(querySpec)) {
       queryDesc = querySpec.call(this, shim, fn, fnName, args)
     }
@@ -728,7 +728,10 @@ function _recordQuery(suffix, nodule, properties, querySpec) {
     // If we're not actually recording this, then just return the segment
     // descriptor now.
     if (hasOwnProperty(queryDesc, 'record') && queryDesc.record === false) {
-      var parameters = _normalizeParameters.call(shim, queryDesc.parameters || Object.create(null))
+      const parameters = _normalizeParameters.call(
+        shim,
+        queryDesc.parameters || Object.create(null)
+      )
       return {
         name: queryDesc.name || fnName,
         parameters,
@@ -743,21 +746,21 @@ function _recordQuery(suffix, nodule, properties, querySpec) {
     }
 
     // Fetch the query string.
-    var queryStr = _extractQueryStr.call(shim, fn, fnName, queryDesc, this, args)
+    const queryStr = _extractQueryStr.call(shim, fn, fnName, queryDesc, this, args)
     if (!shim.isString(queryStr)) {
       return null
     }
 
     // Parse the query and assemble the name.
-    var parsed = shim.parseQuery(queryStr, this)
-    var name = (parsed.collection || 'other') + '/' + parsed.operation + suffix
+    const parsed = shim.parseQuery(queryStr, this)
+    const name = (parsed.collection || 'other') + '/' + parsed.operation + suffix
     shim.logger.trace('Found and parsed query %s -> %s', parsed.type, name)
 
     // Return the segment descriptor.
-    var parameters = _normalizeParameters.call(shim, queryDesc.parameters || Object.create(null))
+    const parameters = _normalizeParameters.call(shim, queryDesc.parameters || Object.create(null))
     return {
       name: shim._metrics.STATEMENT + name,
-      parameters: parameters,
+      parameters,
       callback: 'callback' in queryDesc ? queryDesc.callback : null,
       rowCallback: 'rowCallback' in queryDesc ? queryDesc.rowCallback : null,
       stream: 'stream' in queryDesc ? queryDesc.stream : null,
@@ -794,11 +797,11 @@ function _recordOperationMetrics(segment, scope) {
     return
   }
 
-  var duration = segment.getDurationInMillis()
-  var exclusive = segment.getExclusiveDurationInMillis()
-  var transaction = segment.transaction
-  var type = transaction.isWeb() ? 'allWeb' : 'allOther'
-  var operation = segment.name
+  const duration = segment.getDurationInMillis()
+  const exclusive = segment.getExclusiveDurationInMillis()
+  const transaction = segment.transaction
+  const type = transaction.isWeb() ? 'allWeb' : 'allOther'
+  const operation = segment.name
 
   if (scope) {
     transaction.measure(operation, scope, duration, exclusive)
@@ -845,9 +848,9 @@ function _recordOperationMetrics(segment, scope) {
  * @return {?string} The query from the arguments if found, otherwise `null`.
  */
 function _extractQueryStr(fn, fnName, spec, ctx, args) {
-  var queryStr = spec.query
+  let queryStr = spec.query
   if (this.isNumber(queryStr)) {
-    var queryIdx = this.normalizeIndex(args.length, queryStr)
+    const queryIdx = this.normalizeIndex(args.length, queryStr)
     if (queryIdx === null) {
       this.logger.debug('Invalid query index %d of %d', queryStr, args.length)
       return null
@@ -877,8 +880,8 @@ function _extractQueryStr(fn, fnName, spec, ctx, args) {
  */
 function _normalizeParameters(parameters) {
   parameters = parameters || Object.create(null)
-  var config = this.agent.config
-  var dsTracerConf = config.datastore_tracer
+  const config = this.agent.config
+  const dsTracerConf = config.datastore_tracer
 
   parameters.product = parameters.product || this._datastore
 

package/lib/shim/index.js

@@ -25,9 +25,9 @@ SHIM_TYPE_MAP[constants.MODULE_TYPE.TRANSACTION] = TransactionShim
 SHIM_TYPE_MAP[constants.MODULE_TYPE.WEB_FRAMEWORK] = WebFrameworkShim
 
 function createShimFromType(type, agent, moduleName, resolvedName) {
-  var shim = null
+  let shim = null
   if (properties.hasOwn(SHIM_TYPE_MAP, type)) {
-    var ShimClass = SHIM_TYPE_MAP[type]
+    const ShimClass = SHIM_TYPE_MAP[type]
     shim = new ShimClass(agent, moduleName, resolvedName)
   } else {
     shim = new Shim(agent, moduleName, resolvedName)

package/lib/shim/message-shim.js

@@ -5,16 +5,16 @@
 
 'use strict'
 
-var copy = require('../util/copy')
-var genericRecorder = require('../metrics/recorders/generic')
-var logger = require('../logger').child({ component: 'MessageShim' })
-var messageTransactionRecorder = require('../metrics/recorders/message-transaction')
-var props = require('../util/properties')
-var TransactionShim = require('./transaction-shim')
-var Shim = require('./shim') // For Shim.defineProperty
-var util = require('util')
+const copy = require('../util/copy')
+const genericRecorder = require('../metrics/recorders/generic')
+const logger = require('../logger').child({ component: 'MessageShim' })
+const messageTransactionRecorder = require('../metrics/recorders/message-transaction')
+const props = require('../util/properties')
+const TransactionShim = require('./transaction-shim')
+const Shim = require('./shim') // For Shim.defineProperty
+const util = require('util')
 
-var ATTR_DESTS = require('../config/attribute-filter').DESTINATIONS
+const ATTR_DESTS = require('../config/attribute-filter').DESTINATIONS
 
 /**
  * Enumeration of well-known message brokers.
@@ -332,12 +332,12 @@ function recordProduce(nodule, properties, recordNamer) {
   }
 
   return this.record(nodule, properties, function recordProd(shim) {
-    var msgDesc = recordNamer.apply(this, arguments)
+    const msgDesc = recordNamer.apply(this, arguments)
     if (!msgDesc) {
       return null
     }
 
-    var name = _nameMessageSegment(shim, msgDesc, shim._metrics.PRODUCE)
+    const name = _nameMessageSegment(shim, msgDesc, shim._metrics.PRODUCE)
     if (!shim.agent.config.message_tracer.segment_parameters.enabled) {
       delete msgDesc.parameters
     } else if (msgDesc.routingKey) {
@@ -401,7 +401,7 @@ function recordConsume(nodule, properties, spec) {
     spec = properties
     properties = null
   }
-  var DEFAULT_SPEC = {
+  const DEFAULT_SPEC = {
     destinationName: null,
     promise: false,
     callback: null,
@@ -418,15 +418,15 @@ function recordConsume(nodule, properties, spec) {
     }
 
     return function consumeRecorder() {
-      var parent = shim.getSegment()
+      const parent = shim.getSegment()
       if (!parent || !parent.transaction.isActive()) {
         shim.logger.trace('Not recording consume, no active transaction.')
         return fn.apply(this, arguments)
       }
 
       // Process the message args.
-      var args = shim.argsToArray.apply(shim, arguments)
-      var msgDesc = null
+      const args = shim.argsToArray.apply(shim, arguments)
+      let msgDesc = null
       if (shim.isFunction(spec)) {
         msgDesc = spec.call(this, shim, fn, fnName, args)
         shim.setDefaults(msgDesc, DEFAULT_SPEC)
@@ -438,7 +438,7 @@ function recordConsume(nodule, properties, spec) {
           messageHandler: spec.messageHandler
         }
 
-        var destIdx = shim.normalizeIndex(args.length, spec.destinationName)
+        const destIdx = shim.normalizeIndex(args.length, spec.destinationName)
         if (destIdx !== null) {
           msgDesc.destinationName = args[destIdx]
         }
@@ -457,11 +457,11 @@ function recordConsume(nodule, properties, spec) {
       msgDesc.recorder = genericRecorder
       msgDesc.parent = parent
 
-      var segment = shim.createSegment(msgDesc)
-      var getParams = shim.agent.config.message_tracer.segment_parameters.enabled
-      var resHandler = shim.isFunction(msgDesc.messageHandler) ? msgDesc.messageHandler : null
+      const segment = shim.createSegment(msgDesc)
+      const getParams = shim.agent.config.message_tracer.segment_parameters.enabled
+      const resHandler = shim.isFunction(msgDesc.messageHandler) ? msgDesc.messageHandler : null
 
-      var cbIdx = shim.normalizeIndex(args.length, msgDesc.callback)
+      const cbIdx = shim.normalizeIndex(args.length, msgDesc.callback)
       if (cbIdx !== null) {
         shim.bindCallbackSegment(args, cbIdx, segment)
 
@@ -471,8 +471,8 @@ function recordConsume(nodule, properties, spec) {
           shim.wrap(args, cbIdx, function wrapCb(shim, cb, cbName) {
             if (shim.isFunction(cb)) {
               return function cbWrapper() {
-                var cbArgs = shim.argsToArray.apply(shim, arguments)
-                var msgProps = resHandler.call(this, shim, cb, cbName, cbArgs)
+                const cbArgs = shim.argsToArray.apply(shim, arguments)
+                const msgProps = resHandler.call(this, shim, cb, cbName, cbArgs)
                 if (getParams && msgProps && msgProps.parameters) {
                   shim.copySegmentParameters(segment, msgProps.parameters)
                 }
@@ -485,12 +485,12 @@ function recordConsume(nodule, properties, spec) {
       }
 
       // Call the method in the context of our segment.
-      var ret = shim.applySegment(fn, segment, true, this, args)
+      let ret = shim.applySegment(fn, segment, true, this, args)
 
       // Intercept the promise to handle the result.
       if (resHandler && ret && msgDesc.promise && shim.isPromise(ret)) {
         ret = ret.then(function interceptValue(res) {
-          var msgProps = resHandler.call(this, shim, fn, fnName, res)
+          const msgProps = resHandler.call(this, shim, fn, fnName, res)
           if (getParams && msgProps && msgProps.parameters) {
             shim.copySegmentParameters(segment, msgProps.parameters)
           }
@@ -545,7 +545,7 @@ function recordPurgeQueue(nodule, properties, spec) {
   }
 
   // Fill the spec with defaults.
-  var specIsFunction = this.isFunction(spec)
+  const specIsFunction = this.isFunction(spec)
   if (!specIsFunction) {
     spec = this.setDefaults(spec, {
       queue: null,
@@ -556,14 +556,14 @@ function recordPurgeQueue(nodule, properties, spec) {
   }
 
   return this.record(nodule, properties, function purgeRecorder(shim, fn, name, args) {
-    var descriptor = spec
+    let descriptor = spec
     if (specIsFunction) {
       descriptor = spec.apply(this, arguments)
     }
 
-    var queue = descriptor.queue
+    let queue = descriptor.queue
     if (shim.isNumber(queue)) {
-      var queueIdx = shim.normalizeIndex(args.length, descriptor.queue)
+      const queueIdx = shim.normalizeIndex(args.length, descriptor.queue)
       queue = args[queueIdx]
     }
 
@@ -650,23 +650,23 @@ function recordSubscribedConsume(nodule, properties, spec) {
     return nodule
   }
 
-  var destNameIsArg = this.isNumber(spec.destinationName)
+  const destNameIsArg = this.isNumber(spec.destinationName)
 
   // Must wrap the subscribe method independently to ensure that we can wrap
   // the consumer regardless of transaction state.
-  var wrapped = this.wrap(nodule, properties, function wrapSubscribe(shim, fn) {
+  const wrapped = this.wrap(nodule, properties, function wrapSubscribe(shim, fn) {
     if (!shim.isFunction(fn)) {
       return fn
     }
     return function wrappedSubscribe() {
-      var args = shim.argsToArray.apply(shim, arguments)
-      var queueIdx = shim.normalizeIndex(args.length, spec.queue)
-      var consumerIdx = shim.normalizeIndex(args.length, spec.consumer)
-      var queue = queueIdx === null ? null : args[queueIdx]
-      var destName = null
+      const args = shim.argsToArray.apply(shim, arguments)
+      const queueIdx = shim.normalizeIndex(args.length, spec.queue)
+      const consumerIdx = shim.normalizeIndex(args.length, spec.consumer)
+      const queue = queueIdx === null ? null : args[queueIdx]
+      let destName = null
 
       if (destNameIsArg) {
-        var destNameIdx = shim.normalizeIndex(args.length, spec.destinationName)
+        const destNameIdx = shim.normalizeIndex(args.length, spec.destinationName)
         if (destNameIdx !== null) {
           destName = args[destNameIdx]
         }
@@ -686,8 +686,8 @@ function recordSubscribedConsume(nodule, properties, spec) {
     // This could happen for instance if the function signature is
     // `fn(consumer [, callback])` and specified as `consumer: shim.FIRST`,
     // `callback: shim.LAST`.
-    var consumerIdx = shim.normalizeIndex(args.length, spec.consumer)
-    var cbIdx = shim.normalizeIndex(args.length, spec.callback)
+    const consumerIdx = shim.normalizeIndex(args.length, spec.consumer)
+    let cbIdx = shim.normalizeIndex(args.length, spec.callback)
     if (cbIdx === consumerIdx) {
       cbIdx = null
     }
@@ -703,7 +703,7 @@ function recordSubscribedConsume(nodule, properties, spec) {
   })
 
   function makeWrapConsumer(queue, destinationName) {
-    var msgDescDefaults = copy.shallow(spec)
+    const msgDescDefaults = copy.shallow(spec)
     if (destNameIsArg && destinationName != null) {
       msgDescDefaults.destinationName = destinationName
     }
@@ -720,15 +720,15 @@ function recordSubscribedConsume(nodule, properties, spec) {
         function createConsumeTrans() {
           // If there is no transaction or we're in a pre-existing transaction,
           // then don't do anything. Note that the latter should never happen.
-          var args = shim.argsToArray.apply(shim, arguments)
-          var tx = shim.tracer.getTransaction()
+          const args = shim.argsToArray.apply(shim, arguments)
+          const tx = shim.tracer.getTransaction()
 
           if (!tx || tx.baseSegment) {
             shim.logger.debug({ transaction: !!tx }, 'Failed to start message transaction.')
             return consumer.apply(this, args)
           }
 
-          var msgDesc = spec.messageHandler.call(this, shim, consumer, cName, args)
+          const msgDesc = spec.messageHandler.call(this, shim, consumer, cName, args)
 
           // If message could not be handled, immediately kill this transaction.
           if (!msgDesc) {
@@ -740,7 +740,7 @@ function recordSubscribedConsume(nodule, properties, spec) {
 
           // Derive the transaction name.
           shim.setDefaults(msgDesc, msgDescDefaults)
-          var txName = _nameMessageTransaction(shim, msgDesc)
+          const txName = _nameMessageTransaction(shim, msgDesc)
           tx.setPartialName(txName)
           tx.baseSegment = shim.createSegment({
             name: tx.getFullName(),
@@ -748,7 +748,7 @@ function recordSubscribedConsume(nodule, properties, spec) {
           })
 
           // Add would-be baseSegment attributes to transaction trace
-          for (var key in msgDesc.parameters) {
+          for (const key in msgDesc.parameters) {
             if (props.hasOwn(msgDesc.parameters, key)) {
               tx.trace.attributes.addAttribute(
                 ATTR_DESTS.NONE,
@@ -794,7 +794,7 @@ function recordSubscribedConsume(nodule, properties, spec) {
 
           // Execute the original function and attempt to hook in the transaction
           // finish.
-          var ret = null
+          let ret = null
           try {
             ret = shim.applySegment(consumer, tx.baseSegment, true, this, args)
           } finally {
@@ -838,7 +838,7 @@ function recordSubscribedConsume(nodule, properties, spec) {
  * @return {string} The generated name of the message segment.
  */
 function _nameMessageSegment(shim, msgDesc, action) {
-  var name =
+  let name =
     shim._metrics.PREFIX +
     shim._metrics.LIBRARY +
     '/' +
@@ -856,7 +856,7 @@ function _nameMessageSegment(shim, msgDesc, action) {
 }
 
 function _nameMessageTransaction(shim, msgDesc) {
-  var name = shim._metrics.LIBRARY + '/' + (msgDesc.destinationType || shim.EXCHANGE) + '/'
+  let name = shim._metrics.LIBRARY + '/' + (msgDesc.destinationType || shim.EXCHANGE) + '/'
 
   if (msgDesc.destinationName) {
     name += shim._metrics.NAMED + msgDesc.destinationName

package/lib/shim/promise-shim.js

@@ -154,7 +154,7 @@ class PromiseShim extends Shim {
       }
 
       return function wrappedExecutorCaller(executor) {
-        var parent = shim.getActiveSegment()
+        const parent = shim.getActiveSegment()
         if (!this || !parent) {
           return caller.apply(this, arguments)
         }