newrelic 9.6.0 → 9.7.1

package/lib/environment.js

@@ -10,6 +10,8 @@ const { fsPromises } = require('./util/unwrapped-core')
 const os = require('os')
 const logger = require('./logger').child({ component: 'environment' })
 const stringify = require('json-stringify-safe')
+const asyncEachLimit = require('./util/async-each-limit')
+const DISPATCHER_VERSION = 'Dispatcher Version'
 
 // As of 1.7.0 you can no longer dynamically link v8
 // https://github.com/nodejs/io.js/commit/d726a177ed
@@ -71,7 +73,7 @@ async function listPackages(root, packages = []) {
 
   try {
     const dirs = await fsPromises.readdir(root)
-    await Promise.all(dirs.map(forEachDir))
+    await asyncEachLimit(dirs, forEachDir, 2)
     _log('Done listing packages in %s', root)
   } catch (err) {
     logger.trace(err, 'Could not list packages in %s (probably not an error)', root)
@@ -121,7 +123,7 @@ async function listDependencies(root, children = [], visited = Object.create(nul
 
   try {
     const dirs = await fsPromises.readdir(root)
-    await Promise.all(dirs.map(forEachEntry))
+    await asyncEachLimit(dirs, forEachEntry, 2)
     _log('Done listing dependencies in %s', root)
   } catch (err) {
     logger.trace(err, 'Could not read directories in %s (probably not an error)', root)
@@ -231,7 +233,7 @@ function getGlobalPackages() {
  * package appears at most once, with all the versions joined into a
  * comma-delimited list.
  *
- * @param packages
+ * @param {Array} packages list of packages to process
  * @returns {Array.<string[]>} Sorted list of [name, version] pairs.
  */
 function flattenVersions(packages) {
@@ -307,15 +309,18 @@ async function getOtherPackages() {
   }
   _log('Looking for other packages in %j', paths)
 
-  const pathPromises = paths.map((nodePath) => {
-    if (nodePath[0] !== '/') {
-      nodePath = path.resolve(process.cwd(), nodePath)
-    }
-    _log('Getting other packages from %s', nodePath)
-    return getPackages(nodePath)
-  })
+  const otherPackages = await asyncEachLimit(
+    paths,
+    (nodePath) => {
+      if (nodePath[0] !== '/') {
+        nodePath = path.resolve(process.cwd(), nodePath)
+      }
+      _log('Getting other packages from %s', nodePath)
+      return getPackages(nodePath)
+    },
+    2
+  )
 
-  const otherPackages = await Promise.all(pathPromises)
   otherPackages.forEach((pkg) => {
     other.packages.push.apply(other.packages, pkg.packages)
     other.dependencies.push.apply(other.dependencies, pkg.dependencies)
@@ -418,7 +423,7 @@ function refreshSyncOnly() {
   // gather persisted settings
   const framework = getSetting('Framework')
   const dispatcher = getSetting('Dispatcher')
-  const dispatcherVersion = getSetting('Dispatcher Version')
+  const dispatcherVersion = getSetting(DISPATCHER_VERSION)
 
   // clearing and rebuilding a global variable
   settings = Object.create(null)
@@ -437,7 +442,7 @@ function refreshSyncOnly() {
 
   if (dispatcherVersion.length) {
     dispatcher.forEach(function addDispatchers(d) {
-      addSetting('Dispatcher Version', d)
+      addSetting(DISPATCHER_VERSION, d)
     })
   }
 
@@ -469,7 +474,7 @@ async function refresh() {
  * Refreshes settings and returns the settings object.
  *
  * @private
- * @returns {Promise}
+ * @returns {Promise} the updated/refreshed settings
  */
 async function getJSON() {
   _log('Getting environment JSON')
@@ -503,12 +508,12 @@ module.exports = {
     }
 
     userSetDispatcher = !!userSet
-    clearSetting('Dispatcher Version')
+    clearSetting(DISPATCHER_VERSION)
     clearSetting('Dispatcher')
 
     // TODO: Decide if this should only happen once for internals as well.
     if (version) {
-      addSetting('Dispatcher Version', version)
+      addSetting(DISPATCHER_VERSION, version)
     }
 
     addSetting('Dispatcher', dispatcher)
@@ -520,7 +525,7 @@ module.exports = {
     // This method is only used for tests.
     userSetDispatcher = false
     clearSetting('Dispatcher')
-    clearSetting('Dispatcher Version')
+    clearSetting(DISPATCHER_VERSION)
   },
   listPackages,
   getJSON,

package/lib/errors/error-collector.js

@@ -10,6 +10,7 @@ const errorsModule = require('./index')
 const logger = require('../logger').child({ component: 'error_tracer' })
 const urltils = require('../util/urltils')
 const Exception = require('../errors').Exception
+const Transaction = require('../transaction')
 const errorHelper = require('./helper')
 const createError = errorsModule.createError
 const createEvent = errorsModule.createEvent
@@ -73,6 +74,7 @@ class ErrorCollector {
    *
    * @param {?Transaction}  transaction -
    * @param {Error}         exception   - The error to be checked.
+   * @returns {boolean} whether or not the exception has already been tracked
    */
   _haveSeen(transaction, exception) {
     const txId = transaction ? transaction.id : 'Unknown'
@@ -107,13 +109,78 @@ class ErrorCollector {
     return false
   }
 
+  /**
+   * Helper method for processing errors that are created with .noticeError()
+   *
+   * @param {Transaction} transaction the collected exception's transaction
+   * @param {number} collectedErrors the number of errors we've successfully .collect()-ed
+   * @returns {number} the new number of errors successfully .collect()-ed
+   */
+  _processUserErrors(transaction, collectedErrors) {
+    if (transaction.userErrors.length) {
+      for (let i = 0; i < transaction.userErrors.length; i++) {
+        const exception = transaction.userErrors[i]
+        if (this.collect(transaction, exception)) {
+          ++collectedErrors
+        }
+      }
+    }
+
+    return collectedErrors
+  }
+
+  /**
+   * Helper method for processing exceptions on the transaction (transaction.exceptions array)
+   *
+   * @param {Transaction} transaction the transaction being processed
+   * @param {number} collectedErrors the number of errors successfully .collect()-ed
+   * @param {number} expectedErrors the number of collected errors that were expected
+   * @returns {Array.<number>} the updated [collectedErrors, expectedErrors] numbers post-processing
+   */
+  _processTransactionExceptions(transaction, collectedErrors, expectedErrors) {
+    for (let i = 0; i < transaction.exceptions.length; i++) {
+      const exception = transaction.exceptions[i]
+      if (this.collect(transaction, exception)) {
+        ++collectedErrors
+        // if we could collect it, then check if expected
+        if (
+          urltils.isExpectedError(this.config, transaction.statusCode) ||
+          errorHelper.isExpectedException(transaction, exception.error, this.config, urltils)
+        ) {
+          ++expectedErrors
+        }
+      }
+    }
+
+    return [collectedErrors, expectedErrors]
+  }
+
+  /**
+   * Helper method for processing an inferred error based on Transaction metadata
+   *
+   * @param {Transaction} transaction the transaction being processed
+   * @param {number} collectedErrors the number of errors successfully .collect()-ed
+   * @param {number} expectedErrors the number of collected errors that were expected
+   * @returns {Array.<number>} the updated [collectedErrors, expectedErrors] numbers post-processing
+   */
+  _processTransactionErrors(transaction, collectedErrors, expectedErrors) {
+    if (this.collect(transaction)) {
+      ++collectedErrors
+      if (urltils.isExpectedError(this.config, transaction.statusCode)) {
+        ++expectedErrors
+      }
+    }
+
+    return [collectedErrors, expectedErrors]
+  }
+
   /**
    * Every finished transaction goes through this handler, so do as little as
    * possible.
    *
-   * @param {Transaction} transaction
+   * TODO: Prob shouldn't do any work if errors fully disabled.
    *
-   * @return {number} The number of unexpected errors
+   * @param {Transaction} transaction the completed transaction
    */
   onTransactionFinished(transaction) {
     if (!transaction) {
@@ -123,48 +190,30 @@ class ErrorCollector {
       return
     }
 
-    // TODO: Prob shouldn't do any work if errors fully disabled.
-
     // collect user errors even if status code is ignored
     let collectedErrors = 0
     let expectedErrors = 0
 
     // errors from noticeError are currently exempt from
     // ignore and exclude rules
-    if (transaction.userErrors.length) {
-      for (let i = 0; i < transaction.userErrors.length; i++) {
-        const exception = transaction.userErrors[i]
-        if (this.collect(transaction, exception)) {
-          ++collectedErrors
-        }
-      }
-    }
+    collectedErrors = this._processUserErrors(transaction, collectedErrors)
 
     const isErroredTransaction = urltils.isError(this.config, transaction.statusCode)
     const isIgnoredErrorStatusCode = urltils.isIgnoredError(this.config, transaction.statusCode)
 
-    const isExpectedErrorStatusCode = urltils.isExpectedError(this.config, transaction.statusCode)
-
     // collect other exceptions only if status code is not ignored
     if (transaction.exceptions.length && !isIgnoredErrorStatusCode) {
-      for (let i = 0; i < transaction.exceptions.length; i++) {
-        const exception = transaction.exceptions[i]
-        if (this.collect(transaction, exception)) {
-          ++collectedErrors
-          // if we could collect it, then check if expected
-          if (
-            isExpectedErrorStatusCode ||
-            errorHelper.isExpectedException(transaction, exception.error, this.config, urltils)
-          ) {
-            ++expectedErrors
-          }
-        }
-      }
-    } else if (isErroredTransaction && this.collect(transaction)) {
-      ++collectedErrors
-      if (isExpectedErrorStatusCode) {
-        ++expectedErrors
-      }
+      ;[collectedErrors, expectedErrors] = this._processTransactionExceptions(
+        transaction,
+        collectedErrors,
+        expectedErrors
+      )
+    } else if (isErroredTransaction) {
+      ;[collectedErrors, expectedErrors] = this._processTransactionErrors(
+        transaction,
+        collectedErrors,
+        expectedErrors
+      )
     }
 
     const unexpectedErrors = collectedErrors - expectedErrors
@@ -225,7 +274,8 @@ class ErrorCollector {
    * NOTE: this interface is unofficial and may change in future.
    *
    * @param {?Transaction}  transaction  Transaction associated with the error.
-   * @param {Exception}  exception The Exception to be traced.
+   * @param {*} error The error passed into `API#noticeError()`
+   * @param {object} customAttributes custom attributes to add to the error
    */
   addUserError(transaction, error, customAttributes) {
     if (!error) {
@@ -260,13 +310,38 @@ class ErrorCollector {
    *
    * @param  {?Transaction}  transaction  Transaction associated with the error.
    * @param  {?Exception}  exception  The Exception object to be traced.
-   * @return  {bool}  True if the error was collected.
+   * @returns  {boolean}  True if the error was collected.
    */
-  collect(transaction, exception) {
-    if (!exception) {
-      exception = new Exception({})
+  collect(transaction, exception = new Exception({})) {
+    if (!this._isValidException(exception, transaction)) {
+      return false
     }
 
+    const errorTrace = createError(transaction, exception, this.config)
+    this._maybeRecordErrorMetrics(errorTrace, transaction)
+
+    // defaults true in config/index. can be modified server-side
+    if (this.config.collect_errors) {
+      this.traceAggregator.add(errorTrace)
+    }
+
+    if (this.config.error_collector.capture_events === true) {
+      const priority = (transaction && transaction.priority) || Math.random()
+      const event = createEvent(transaction, errorTrace, exception.timestamp, this.config)
+      this.eventAggregator.add(event, priority)
+    }
+
+    return true
+  }
+
+  /**
+   * Helper method for ensuring that a collected exception/transaction combination can be collected
+   *
+   * @param {object} exception the exception to validate
+   * @param {Transaction} transaction the Transaction to validate, if exception is malformed we'll try to fallback to transaction data
+   * @returns {boolean} whether or not the exception/transaction combo has everything needed for processing
+   */
+  _isValidException(exception, transaction) {
     if (exception.error) {
       if (this._haveSeen(transaction, exception.error)) {
         return false
@@ -285,10 +360,20 @@ class ErrorCollector {
 
     if (exception.error) {
       logger.trace(exception.error, 'Got exception to trace:')
+    } else {
+      logger.trace(transaction, 'Got transaction error to trace:')
     }
 
-    const errorTrace = createError(transaction, exception, this.config)
+    return true
+  }
 
+  /**
+   * Helper method for recording metrics about errors depending on the type of error that happened
+   *
+   * @param {Array} errorTrace list of error information
+   * @param {Transaction} transaction the transaction associated with the trace
+   */
+  _maybeRecordErrorMetrics(errorTrace, transaction) {
     const isExpectedError = true === errorTrace[4].intrinsics['error.expected']
 
     if (isExpectedError) {
@@ -304,19 +389,6 @@ class ErrorCollector {
         }
       }
     }
-
-    // defaults true in config/index. can be modified server-side
-    if (this.config.collect_errors) {
-      this.traceAggregator.add(errorTrace)
-    }
-
-    if (this.config.error_collector.capture_events === true) {
-      const priority = (transaction && transaction.priority) || Math.random()
-      const event = createEvent(transaction, errorTrace, exception.timestamp, this.config)
-      this.eventAggregator.add(event, priority)
-    }
-
-    return true
   }
 
   // TODO: ideally, this becomes unnecessary

package/lib/errors/helper.js

@@ -21,20 +21,17 @@ module.exports = {
     if (!config.error_collector.expected_messages[type]) {
       return false
     }
-    if (config.error_collector.expected_messages[type].length > 0) {
-      if (-1 !== config.error_collector.expected_messages[type].indexOf(message)) {
-        return true
-      }
-    }
-    return false
+
+    return (
+      config.error_collector.expected_messages[type].length > 0 &&
+      config.error_collector.expected_messages[type].indexOf(message) !== -1
+    )
   },
   isExpectedErrorClass: function isExpectedErrorClass(config, className) {
-    if (config.error_collector.expected_classes.length > 0) {
-      if (-1 !== config.error_collector.expected_classes.indexOf(className)) {
-        return true
-      }
-    }
-    return false
+    return (
+      config.error_collector.expected_classes.length > 0 &&
+      config.error_collector.expected_classes.indexOf(className) !== -1
+    )
   },
   isExpectedException: function isExpectedException(transaction, exception, config, urltils) {
     const { type, message } = this.extractErrorInformation(transaction, exception, config, urltils)
@@ -123,11 +120,6 @@ module.exports = {
       return false
     }
 
-    if (configIgnoreMessages.length > 0) {
-      if (-1 !== configIgnoreMessages.indexOf(errorInfo.message)) {
-        return true
-      }
-    }
-    return false
+    return configIgnoreMessages.length > 0 && configIgnoreMessages.indexOf(errorInfo.message) !== -1
   }
 }

package/lib/errors/index.js

@@ -6,10 +6,17 @@
 'use strict'
 
 const DESTINATIONS = require('../config/attribute-filter').DESTINATIONS
-const NAMES = require('../metrics/names')
 const props = require('../util/properties')
 const urltils = require('../util/urltils')
 const errorHelper = require('../errors/helper')
+const {
+  maybeAddQueueAttributes,
+  maybeAddExternalAttributes,
+  maybeAddDatabaseAttributes,
+  maybeAddSyntheticAttributes
+} = require('../util/attributes')
+const Transaction = require('../transaction')
+const ERROR_EXPECTED_PATH = 'error.expected'
 
 class Exception {
   constructor({ error, timestamp, customAttributes, agentAttributes }) {
@@ -45,9 +52,19 @@ class Exception {
  * handler, which traps actual instances of Error, try to set sensible
  * defaults for everything.
  *
+ * NOTE: this function returns an array, but also conditionally mutates the array
+ * to add a "transaction" property with the transaction id to the array, which works
+ * because everything's an object in JS. I'm not entirely sure why we do this, but
+ * weird enough to make note of
+ *
  * @param {Transaction} transaction  The agent transaction, coming from the instrumentatation
  * @param {Exception}   exception    An custom Exception object with the error and other information
  * @param {object}      config       The configuration to use when creating the object
+ * @returns {Array} an Array of Error information, [0] -> placeholder,
+ *                                                 [1] -> name extracted from error info,
+ *                                                 [2] -> extracted error message,
+ *                                                 [3] -> extracted error type,
+ *                                                 [4] -> attributes
  */
 function createError(transaction, exception, config) {
   const error = exception.error
@@ -67,55 +84,74 @@ function createError(transaction, exception, config) {
   if (transaction) {
     // Copy all of the parameters off of the transaction.
     params.intrinsics = transaction.getIntrinsicAttributes()
-    let transactionAgentAttributes = transaction.trace.attributes.get(DESTINATIONS.ERROR_EVENT)
-    transactionAgentAttributes = transactionAgentAttributes || {}
+    const transactionAgentAttributes =
+      transaction.trace.attributes.get(DESTINATIONS.ERROR_EVENT) || {}
 
     // Merge the agent attributes specific to this error event with the transaction attributes
-    const agentAttributes = Object.assign(exception.agentAttributes, transactionAgentAttributes)
-    params.agentAttributes = agentAttributes
+    params.agentAttributes = Object.assign(exception.agentAttributes, transactionAgentAttributes)
 
     // There should be no attributes to copy in HSM, but check status anyway
     if (!config.high_security) {
-      const custom = transaction.trace.custom.get(DESTINATIONS.ERROR_EVENT)
-      urltils.overwriteParameters(custom, params.userAttributes)
+      urltils.overwriteParameters(
+        transaction.trace.custom.get(DESTINATIONS.ERROR_EVENT),
+        params.userAttributes
+      )
     }
   }
 
+  maybeAddUserAttributes(params.userAttributes, exception, config)
+
+  params.stack_trace = maybeAddStackTrace(exception, config)
+
+  params.intrinsics[ERROR_EXPECTED_PATH] = errorHelper.isExpected(
+    type,
+    message,
+    transaction,
+    config,
+    urltils
+  )
+
+  return [0, name, message, type, params]
+}
+
+function maybeAddUserAttributes(userAttributes, exception, config) {
   const customAttributes = exception.customAttributes
   if (!config.high_security && config.api.custom_attributes_enabled && customAttributes) {
     for (const key in customAttributes) {
       if (props.hasOwn(customAttributes, key)) {
         const dest = config.attributeFilter.filterTransaction(DESTINATIONS.ERROR_EVENT, key)
         if (dest & DESTINATIONS.ERROR_EVENT) {
-          params.userAttributes[key] = customAttributes[key]
+          userAttributes[key] = customAttributes[key]
         }
       }
     }
   }
+}
+
+function maybeAddStackTrace(exception, config) {
+  const stack = exception.error?.stack
+  let parsedStack
 
-  const stack = exception.error && exception.error.stack
   if (stack) {
-    params.stack_trace = ('' + stack).split(/[\n\r]/g)
+    parsedStack = ('' + stack).split(/[\n\r]/g)
+
     if (config.high_security || config.strip_exception_messages.enabled) {
-      params.stack_trace[0] = exception.error.name + ': <redacted>'
+      parsedStack[0] = exception.error.name + ': <redacted>'
     }
   }
 
-  params.intrinsics['error.expected'] = false
-  if (errorHelper.isExpected(type, message, transaction, config, urltils)) {
-    params.intrinsics['error.expected'] = true
-  }
-
-  const res = [0, name, message, type, params]
-  if (transaction) {
-    res.transaction = transaction.id
-  }
-  return res
+  return parsedStack
 }
 
 /**
  * Creates a structure for error event that is sent to the collector.
  * The error parameter is an output of the createError() function for a given exception.
+ *
+ * @param {Transaction} transaction the current transaction
+ * @param {Array} error createError() output
+ * @param {string} timestamp the timestamp of the error event
+ * @param {object} config agent configuration object
+ * @returns {Array} an Array of different types of attributes [0] -> intrinsic, [1] -> user/custom, [2] -> agent
  */
 function createEvent(transaction, error, timestamp, config) {
   const message = error[2]
@@ -126,7 +162,7 @@ function createEvent(transaction, error, timestamp, config) {
     transaction,
     errorClass,
     message,
-    errorParams.intrinsics['error.expected'],
+    errorParams.intrinsics[ERROR_EXPECTED_PATH],
     timestamp,
     config
   )
@@ -136,9 +172,7 @@ function createEvent(transaction, error, timestamp, config) {
   const userAttributes = Object.assign(Object.create(null), errorParams.userAttributes)
   const agentAttributes = Object.assign(Object.create(null), errorParams.agentAttributes)
 
-  const errorEvent = [intrinsicAttributes, userAttributes, agentAttributes]
-
-  return errorEvent
+  return [intrinsicAttributes, userAttributes, agentAttributes]
 }
 
 // eslint-disable-next-line max-params
@@ -160,28 +194,10 @@ function _getErrorEventIntrinsicAttrs(transaction, errorClass, message, expected
     attributes.transactionName = transaction.getFullName()
     attributes.duration = transaction.timer.getDurationInMillis() / 1000
 
-    let metric = transaction.metrics.getMetric(NAMES.QUEUETIME)
-    if (metric) {
-      attributes.queueDuration = metric.total
-    }
-
-    metric = transaction.metrics.getMetric(NAMES.EXTERNAL.ALL)
-    if (metric) {
-      attributes.externalDuration = metric.total
-      attributes.externalCallCount = metric.callCount
-    }
-
-    metric = transaction.metrics.getMetric(NAMES.DB.ALL)
-    if (metric) {
-      attributes.databaseDuration = metric.total
-      attributes.databaseCallCount = metric.callCount
-    }
-
-    if (transaction.syntheticsData) {
-      attributes['nr.syntheticsResourceId'] = transaction.syntheticsData.resourceId
-      attributes['nr.syntheticsJobId'] = transaction.syntheticsData.jobId
-      attributes['nr.syntheticsMonitorId'] = transaction.syntheticsData.monitorId
-    }
+    maybeAddQueueAttributes(transaction, attributes)
+    maybeAddExternalAttributes(transaction, attributes)
+    maybeAddDatabaseAttributes(transaction, attributes)
+    maybeAddSyntheticAttributes(transaction, attributes)
 
     if (transaction.agent.config.distributed_tracing.enabled) {
       transaction.addDistributedTraceIntrinsics(attributes)

package/lib/grpc/connection.js

@@ -41,9 +41,9 @@ class GrpcConnection extends EventEmitter {
    * Standard property setting/initialization, and sets an initial
    * connection state of disconnected
    *
-   * @param {Object} traceObserverConfig config item config.infinite_tracing.trace_observer
+   * @param {object} traceObserverConfig config item config.infinite_tracing.trace_observer
    * @param {MetricAggregator} metrics metric aggregator, for supportability metrics
-   * @param {Number} [reconnectDelayMs=15000] number of milliseconds to wait before reconnecting
+   * @param {number} [reconnectDelayMs=15000] number of milliseconds to wait before reconnecting
    * for error states that require a reconnect delay.
    */
   constructor(traceObserverConfig, metrics, reconnectDelayMs) {
@@ -97,6 +97,7 @@ class GrpcConnection extends EventEmitter {
    *
    * @param {int} state The connection state (See connectionStates above)
    * @param {ClientDuplexStreamImpl} state The GRPC stream, when defined
+   * @param stream
    */
   _setState(state, stream = null) {
     this._state = state
@@ -146,6 +147,8 @@ class GrpcConnection extends EventEmitter {
    *
    * @param {string} licenseKey
    * @param {string} runId
+   * @param requestHeadersMap
+   * @param env
    */
   _getMetadata(licenseKey, runId, requestHeadersMap, env) {
     const metadata = new grpc.Metadata()
@@ -170,6 +173,7 @@ class GrpcConnection extends EventEmitter {
    * when appropriate env vars are set
    *
    * @param {Metadata} metadata
+   * @param env
    */
   _setTestMetadata(metadata, env) {
     for (const [key, envVar] of Object.entries(GRPC_TEST_META)) {
@@ -183,6 +187,7 @@ class GrpcConnection extends EventEmitter {
 
   /**
    * Disconnects from gRPC endpoint and schedules establishing a new connection.
+   *
    * @param {number} reconnectDelayMs number of milliseconds to wait before reconnecting.
    */
   _reconnect(reconnectDelayMs = 0) {
@@ -291,6 +296,8 @@ class GrpcConnection extends EventEmitter {
 
   /**
    * Creates the GRPC credentials needed
+   *
+   * @param grpcApi
    */
   _generateCredentials(grpcApi) {
     let certBuffer = null
@@ -349,6 +356,8 @@ class GrpcConnection extends EventEmitter {
    * ChannelImplementation and related objects will stay in memory even after
    * the stream is closed and we do not have a handle to the client. Currently
    * impacting grpc-js@1.2.11 and several earlier versions.
+   *
+   * @param endpoint
    */
   _createClient(endpoint) {
     logger.trace('Creating gRPC client for: ', endpoint)
@@ -360,9 +369,7 @@ class GrpcConnection extends EventEmitter {
     const traceApi = protoDescriptor.com.newrelic.trace.v1
 
     const credentials = this._generateCredentials(grpc)
-    const client = new traceApi.IngestService(endpoint, credentials)
-
-    return client
+    return new traceApi.IngestService(endpoint, credentials)
   }
 }
 

package/lib/header-attributes.js

@@ -139,7 +139,8 @@ function _collectHeaders(headers, nameMap, prefix, transaction) {
 
 /**
  * Adds request headers as request.headers.* attributes to the given transaction.
- * @param {Object.<string, string>} headers - Request headers to add attributes for.
+ *
+ * @param {Object<string, string>} headers - Request headers to add attributes for.
  * @param {Transaction} transaction - Transaction to add header attributes to.
  */
 function collectRequestHeaders(headers, transaction) {
@@ -148,7 +149,8 @@ function collectRequestHeaders(headers, transaction) {
 
 /**
  * Adds response headers as response.headers.* attributes to the given transaction.
- * @param {Object.<string, string>} headers - Response headers to add attributes for.
+ *
+ * @param {Object<string, string>} headers - Response headers to add attributes for.
  * @param {Transaction} transaction - Transaction to add header attributes to.
  */
 function collectResponseHeaders(headers, transaction) {