newrelic 6.4.0 → 6.6.0

package/index.js

@@ -43,10 +43,10 @@ function initialize() {
       preAgentTime
     )
 
-    // TODO: Update this check when Node v6 is deprecated.
-    if (psemver.satisfies('<6.0.0')) {
+    // TODO: Update this check when Node v8 is deprecated.
+    if (psemver.satisfies('<8.0.0')) {
       message = 'New Relic for Node.js requires a version of Node equal to or\n' +
-                'greater than 6.0.0. Not starting!'
+                'greater than 8.0.0. Not starting!'
 
       logger.error(message)
       throw new Error(message)

package/lib/agent.js

@@ -18,12 +18,12 @@ const NAMES = require('./metrics/names')
 const QueryTraceAggregator = require('./db/query-trace-aggregator')
 const sampler = require('./sampler')
 const TransactionTraceAggregator = require('./transaction/trace/aggregator')
-const SpanEventAggregator = require('./spans/span-event-aggregator')
 const TransactionEventAggregator = require('./transaction/transaction-event-aggregator')
 const Tracer = require('./transaction/tracer')
 const TxSegmentNormalizer = require('./metrics/normalizer/tx_segment')
 const uninstrumented = require('./uninstrumented')
 const util = require('util')
+const createSpanEventAggregator = require('./spans/create-span-event-aggregator')
 
 // Map of valid states to whether or not data collection is valid
 const STATES = {
@@ -84,13 +84,7 @@ function Agent(config) {
     this._beforeMetricDataSend.bind(this)
   )
 
-  // Open tracing.
-  this.spanEventAggregator = new SpanEventAggregator({
-    periodMs: config.event_harvest_config.report_period_ms,
-    limit: config.event_harvest_config.harvest_limits.span_event_data
-  },
-  this.collector,
-  this.metrics)
+  this.spanEventAggregator = createSpanEventAggregator(config, this.collector, this.metrics)
 
   this.transactionNameNormalizer = new MetricNormalizer(this.config, 'transaction name')
   // Segment term based tx renaming for MGI mitigation.
@@ -249,6 +243,10 @@ Agent.prototype.start = function start(callback) {
         agent.startAggregators()
         callback(null, config)
       } else {
+        // For data collection that streams immediately, dont delay capture/sending until
+        // the harvest of everything else has completed.
+        agent.startStreaming()
+
         // Harvest immediately for quicker data display, but after at least 1
         // second or the collector will throw away the data.
         //
@@ -409,6 +407,16 @@ Agent.prototype.stopAggregators = function stopAggregators() {
   this.customEventAggregator.stop()
 }
 
+Agent.prototype.startStreaming = function startStreaming() {
+  if (
+    this.spanEventAggregator.isStream &&
+    this.config.distributed_tracing.enabled &&
+    this.config.span_events.enabled
+  ) {
+    this.spanEventAggregator.start()
+  }
+}
+
 Agent.prototype.startAggregators = function startAggregators() {
   this.metrics.start()
   this.errors.start()
@@ -798,6 +806,12 @@ Agent.prototype.setLambdaArn = function setLambdaArn(arn) {
   }
 }
 
+Agent.prototype.setLambdaFunctionVersion = function setLambdaFunctionVersion(function_version) {
+  if (this.collector instanceof ServerlessCollector) {
+    this.collector.setLambdaFunctionVersion(function_version)
+  }
+}
+
 /**
  * Get the current transaction (if there is one) from the tracer.
  *

package/lib/aggregators/base-aggregator.js

@@ -88,7 +88,7 @@ class Aggregator extends EventEmitter {
   }
 
   send() {
-    logger.info(`${this.method} Aggregator data send.`)
+    logger.debug(`${this.method} Aggregator data send.`)
     this.emit(`starting ${this.method} data send.`)
 
     const data = this._getMergeData()

package/lib/attributes.js

@@ -6,6 +6,8 @@ const isValidType = require('./util/attribute-types')
 const byteUtils = require('./util/byte-limit')
 const properties = require('./util/properties')
 
+const MAXIMUM_CUSTOM_ATTRIBUTES = 64
+
 /**
  * @class
  * @private
@@ -23,6 +25,7 @@ class Attributes {
     this.filter = makeFilter(scope)
     this.limit = limit
     this.attributes = Object.create(null)
+    this.attributeCount = 0
   }
 
   /**
@@ -57,7 +60,6 @@ class Attributes {
    */
   get(dest) {
     const attrs = Object.create(null)
-    let attrCount = 0
     for (let key in this.attributes) { // eslint-disable-line guard-for-in
       const attr = this.attributes[key]
       if (!(attr.destinations & dest)) {
@@ -67,10 +69,6 @@ class Attributes {
       attrs[key] = typeof attr.value === 'string' && !attr.truncateExempt
         ? byteUtils.truncate(attr.value, 255)
         : attr.value
-
-      if (++attrCount >= this.limit) {
-        break
-      }
     }
 
     return attrs
@@ -103,6 +101,13 @@ class Attributes {
    * @param {boolean} [truncateExempt=false] - Flag marking value exempt from truncation
    */
   addAttribute(destinations, key, value, truncateExempt = false) {
+    if (this.attributeCount + 1 > this.limit) {
+      return logger.debug(
+        `Maximum number of custom attributes have been added.  
+        Dropping attribute ${key} with ${value} type.`
+      )
+    }
+
     if (!isValidType(value)) {
       return logger.debug(
         'Not adding attribute %s with %s value type. This is expected for undefined' +
@@ -123,6 +128,7 @@ class Attributes {
     // Only set the attribute if at least one destination passed
     const validDestinations = this.filter(destinations, key)
     if (validDestinations) {
+      this.attributeCount = this.attributeCount + 1
       this._set(validDestinations, key, value, truncateExempt)
     }
   }
@@ -159,4 +165,7 @@ function makeFilter(scope) {
   }
 }
 
-module.exports = Attributes
+module.exports = {
+  Attributes: Attributes,
+  MAXIMUM_CUSTOM_ATTRIBUTES: MAXIMUM_CUSTOM_ATTRIBUTES
+}

package/lib/collector/serverless.js

@@ -24,6 +24,7 @@ class ServerlessCollector {
     this.enabled = true
     this.metadata = {
       arn: null,
+      function_version: null,
       execution_environment: process.env.AWS_EXECUTION_ENV,
       protocol_version: 16,
       agent_version: agent.version
@@ -38,6 +39,13 @@ class ServerlessCollector {
     this.metadata.arn = arn
   }
 
+  /**
+   * Sets the function_version to be sent up in the metadata.
+   */
+  setLambdaFunctionVersion(function_version) {
+    this.metadata.function_version = function_version
+  }
+
   /**
    * Checks if the collector is currently collecting.
    *

package/lib/config/default.js

@@ -456,6 +456,8 @@ exports.config = () => ({
      * or 'obfuscated' and other criteria (slow_sql.enabled etc) are met
      * for a query. The raw or obfuscated sql will be included in the
      * transaction trace and a slow query sample will be collected.
+     *
+     * @env NEW_RELIC_RECORD_SQL
      */
     record_sql: 'off',
 
@@ -882,6 +884,26 @@ exports.config = () => ({
     segment_parameters: {enabled: true}
   },
 
+  /**
+   * Controls the use of infinite tracing.
+   */
+  infinite_tracing: {
+    trace_observer: {
+      /**
+       * The URI HOST of the observer.  Setting this enables infinite tracing.
+       * 
+       * @env NEW_RELIC_INFINITE_TRACING_TRACE_OBSERVER_HOST
+       */
+      host: '',
+      /**
+       * The URI PORT of the observer.
+       * 
+       * @env NEW_RELIC_INFINITE_TRACING_TRACE_OBSERVER_PORT
+       */
+      port: '443'
+    }
+  },
+
   /**
    * Specifies whether the agent will be used to monitor serverless functions.
    * For example: AWS Lambda
@@ -898,5 +920,5 @@ exports.config = () => ({
      * loop data.
      */
     native_metrics: {enabled: true}
-  },
+  }
 })

package/lib/config/env.js

@@ -152,7 +152,13 @@ const ENV_MAPPING = {
   },
   trusted_account_key: 'NEW_RELIC_TRUSTED_ACCOUNT_KEY',
   primary_application_id: 'NEW_RELIC_PRIMARY_APPLICATION_ID',
-  account_id: 'NEW_RELIC_ACCOUNT_ID'
+  account_id: 'NEW_RELIC_ACCOUNT_ID',
+  infinite_tracing: {
+    trace_observer: {
+      host: 'NEW_RELIC_INFINITE_TRACING_TRACE_OBSERVER_HOST',
+      port: 'NEW_RELIC_INFINITE_TRACING_TRACE_OBSERVER_PORT'
+    }
+  }
 }
 
 // List of environment values which are comma-delimited lists.

package/lib/config/hsm.js

@@ -51,7 +51,12 @@ const HIGH_SECURITY_SETTINGS = {
 const HIGH_SECURITY_KEYS = flatten.keys(HIGH_SECURITY_SETTINGS)
 
 // blank out these config values before sending to the collector
-const REDACT_BEFORE_SEND = new Set(['proxy_pass', 'proxy_user', 'proxy'])
+const REDACT_BEFORE_SEND = new Set([
+  'proxy_pass',
+  'proxy_user',
+  'proxy',
+  'certificates' // should be public but in case user mistake and also these are huge
+])
 
 // process.domain needs to be stripped befeore sending
 const REMOVE_BEFORE_SEND = new Set(['domain'])

package/lib/config/index.js

@@ -1152,15 +1152,15 @@ Config.prototype._loggingManuallySet = function _loggingManuallySet(inputConfig)
 /**
  * Returns true if native-metrics has been manually enabled via configuration
  * file or enveironment variable
- * 
+ *
  * @param {*} inputConfig configuration pass to the Config constructor
- * 
+ *
  * @returns {boolean}
  */
-Config.prototype._nativeMetricsManuallySet = 
+Config.prototype._nativeMetricsManuallySet =
   function _nativeMetricsManuallySet(inputConfig) {
-    const inputEnabled = inputConfig 
-      && inputConfig.plugins 
+    const inputEnabled = inputConfig
+      && inputConfig.plugins
       && inputConfig.plugins.native_metrics
       && inputConfig.plugins.native_metrics.enabled
     const envEnabled = process.env.NEW_RELIC_NATIVE_METRICS_ENABLED
@@ -1201,6 +1201,12 @@ Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
       logger.info('Cross application tracing is explicitly disabled in serverless_mode.')
     }
 
+    if (this.infinite_tracing.trace_observer.host) {
+      this.infinite_tracing.trace_observer.host = ''
+      this.infinite_tracing.trace_observer.port = ''
+      logger.info('Infinite tracing is explicitly disabled in serverless_mode.')
+    }
+
     if (!this._loggingManuallySet(inputConfig)) {
       this.logging.enabled = false
 
@@ -1211,7 +1217,7 @@ Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
       )
     }
 
-    if (this._nativeMetricsManuallySet(inputConfig) && 
+    if (this._nativeMetricsManuallySet(inputConfig) &&
       this.plugins.native_metrics.enabled) {
       logger.info(
         'Enabling the native-metrics module when in serverless mode may greatly ' +
@@ -1253,6 +1259,7 @@ Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
 
     return
   }
+
   const DT_KEYS = ['account_id', 'primary_application_id', 'trusted_account_key']
   // Don't allow DT config settings to be set if serverless_mode is disabled
   DT_KEYS.forEach((key) => {
@@ -1458,8 +1465,12 @@ Config.prototype.applyLasp = function applyLasp(agent, policies) {
       }
       var valueName = splitConfigName[splitConfigName.length - 1]
       var localVal = settingBlock[valueName]
+
+      // Indexes into "allowed values" based on "enabled" setting
+      // to retreive proper mapping.
       var policyValues = localMapping.allowedValues
       var policyValue = policyValues[policy.enabled ? 1 : 0]
+
       // get the most secure setting between local config and the policy
       var finalValue = settingBlock[valueName] = config._getMostSecure(
         name,
@@ -1522,6 +1533,20 @@ Config.prototype.validateFlags = function validateFlags() {
   })
 }
 
+function redactValue(value) {
+  const REDACT_VALUE = '****'
+
+  let result = null
+  if (Array.isArray(value)) {
+    // Redact each value so we know if was configured and how many values
+    result = value.map(() => REDACT_VALUE)
+  } else {
+    result = REDACT_VALUE
+  }
+
+  return result
+}
+
 /**
  * Get a JSONifiable object containing all settings we want to report to the
  * collector and store in the environment_values table.
@@ -1532,9 +1557,10 @@ Config.prototype.publicSettings = function publicSettings() {
   var settings = Object.create(null)
 
   for (var key in this) {
-    if (this.hasOwnProperty(key)) {
+    if (this.hasOwnProperty(key) && !REMOVE_BEFORE_SEND.has(key)) {
       if (HSM.REDACT_BEFORE_SEND.has(key)) {
-        settings[key] = '****'
+        const value = this[key]
+        settings[key] = redactValue(value)
       } else if (!HSM.REMOVE_BEFORE_SEND.has(key)) {
         settings[key] = this[key]
       }
@@ -1695,6 +1721,8 @@ function createInstance(config) {
   return _configInstance
 }
 
+const REMOVE_BEFORE_SEND = new Set(['attributeFilter'])
+
 /**
  * Preserve the legacy initializer, but also allow consumers to manage their
  * own configuration if they choose.

package/lib/config/lasp.js

@@ -1,12 +1,25 @@
 'use strict'
 
+// TODO: would likely be easier to understand if the allowedValues mapping
+// just took the raw enabled/disabled and translated. This is not a hot path.
+
+/**
+ * path: Full nested path for the local configuration item.
+ * allowedValues:
+ *   Array of valid config values to map for incoming enabled/disabled.
+ *   policy.enabled: false uses index 0, policy.enabled: true uses index 1.
+ * filter: Allows for calculating most secure setting to use
+ * applyAdditionalSettings: Applies additional settings that are required
+ *   when the policy is disabled.
+ * clearData: Clears the relevant agent collection.
+ */
 const LASP_MAP = {
   // LASP key
   record_sql: {
     // full path to corresponding config key
     path: 'transaction_tracer.record_sql',
     // Mapping from policy enabled status to usable config value
-    // first element is policy is off, second is policy is on
+    // policy.enabled: false === off, policy.enabled: true === 'obfuscated'
     allowedValues: ['off', 'obfuscated'],
     // Tracks the precedent of settings controlled by LASP.
     filter: function mostSecureRecordSQL(first, second) {
@@ -45,6 +58,8 @@ const LASP_MAP = {
   // TODO: rename config key, because the names contradict each other's behavior
   allow_raw_exception_messages: {
     path: 'strip_exception_messages.enabled',
+    // if raw messages are allowed, then we should not strip them
+    // policy.enabled: false === true, policy.enabled: true === false
     allowedValues: [true, false],
     filter: function mostSecureStripException(first, second) {
       return first || second

package/lib/errors/error-collector.js

@@ -4,6 +4,7 @@ const errorsModule = require('./index')
 
 const logger = require('../logger').child({component: 'error_tracer'})
 const urltils = require('../util/urltils')
+const Exception = require('../errors').Exception
 const errorHelper = require('./helper')
 const createError = errorsModule.createError
 const createEvent = errorsModule.createEvent
@@ -129,7 +130,7 @@ class ErrorCollector {
     if (transaction.userErrors.length) {
       for (let i = 0; i < transaction.userErrors.length; i++) {
         const exception = transaction.userErrors[i]
-        if (this._collect(transaction, exception[0], exception[1], exception[2])) {
+        if (this.collect(transaction, exception)) {
           ++collectedErrors
         }
       }
@@ -145,13 +146,13 @@ class ErrorCollector {
     if (transaction.exceptions.length) {
       for (let i = 0; i < transaction.exceptions.length; i++) {
         const exception = transaction.exceptions[i]
-        if (this.collect(transaction, exception[0], exception[1], exception[2])) {
+        if (this.collect(transaction, exception)) {
           ++collectedErrors
           // if we could collect it, then check if expected
           if (isExpectedErrorStatusCode ||
             errorHelper.isExpectedException(
               transaction,
-              exception[0],
+              exception.error,
               this.config,
               urltils
             )
@@ -178,31 +179,32 @@ class ErrorCollector {
   }
 
   /**
-   * This function collects the error right away when transaction is not supplied.
-   * Otherwise it delays collecting the error until the transaction ends.
+   * This function collects the error right away when transaction is not supplied. Otherwise it
+   * delays collecting the error until the transaction ends.
    *
    * NOTE: this interface is unofficial and may change in future.
    *
-   * @param {?Transaction} transaction
-   *  Transaction associated with the error.
-   *
-   * @param {Error} exception
-   *  The error to be traced.
-   *
-   * @param {object} customAttributes
-   *  Any custom attributes associated with the request (optional).
+   * @param {?Transaction}  transaction  Transaction associated with the error.
+   * @param {Error}  error  The error to be traced.
+   * @param {?object}  customAttributes  Custom attributes associated with the request (optional).
    */
-  add(transaction, exception, customAttributes) {
-    if (!exception) {
+  add(transaction, error, customAttributes) {
+    if (!error) {
+      return
+    }
+
+    if (errorHelper.shouldIgnoreError(transaction, error, this.config)) {
+      logger.trace('Ignoring error')
       return
     }
 
     const timestamp = Date.now()
+    const exception = new Exception({error, timestamp, customAttributes})
 
     if (transaction) {
-      transaction.addException(exception, customAttributes, timestamp)
+      transaction.addException(exception)
     } else {
-      this.collect(transaction, exception, customAttributes, timestamp)
+      this.collect(transaction, exception)
     }
   }
 
@@ -217,95 +219,54 @@ class ErrorCollector {
    *
    * NOTE: this interface is unofficial and may change in future.
    *
-   * @param {?Transaction} transaction
-   *  Transaction associated with the error.
-   *
-   * @param {Error} exception
-   *  The error to be traced.
-   *
-   * @param {object} [customAttributes=null]
-   *  Any custom attributes associated with the request (optional).
+   * @param {?Transaction}  transaction  Transaction associated with the error.
+   * @param {Exception}  exception The Exception to be traced.
    */
-  addUserError(transaction, exception, customAttributes) {
-    if (!exception) return
+  addUserError(transaction, error, customAttributes) {
+    if (!error) return
 
-    var timestamp = Date.now()
+    const timestamp = Date.now()
+    const exception = new Exception({error, timestamp, customAttributes})
 
     if (transaction) {
-      transaction.addUserError(exception, customAttributes, timestamp)
+      transaction.addUserError(exception)
     } else {
-      this._collect(transaction, exception, customAttributes, timestamp)
-    }
-  }
-
-  /**
-   * Wrapper for _collect, include logic for whether an error should
-   * be ignored or not.  Exists to allow userErrors to bypass ignore
-   * logic.
-   *
-   * NOTE: this interface is unofficial and may change in future.
-   *
-   * @param {?Transaction} transaction
-   *  Transaction associated with the error.
-   *
-   * @param {?Error} exception
-   *  The error to be traced.
-   *
-   * @param {?object} customAttributes
-   *  Any custom attributes associated with the request.
-   *
-   * @param {number} timestamp
-   *
-   * @return {bool} True if the error was collected.
-   */
-  collect(transaction, exception, customAttributes, timestamp) {
-    if (errorHelper.shouldIgnoreError(transaction, exception, this.config)) {
-      logger.trace("Ignoring error")
-      return
+      this.collect(transaction, exception)
     }
-    return this._collect(transaction, exception, customAttributes, timestamp)
   }
 
   /**
    * Collects the error and also creates the error event.
    *
-   * @private
-   *
-   * This function uses an array of seen exceptions to ensure errors don't get
-   * double-counted. It can also be used as an unofficial means of marking that
-   * user errors shouldn't be traced.
+   * This function uses an array of seen exceptions to ensure errors don't get double-counted. It
+   * can also be used as an unofficial means of marking that user errors shouldn't be traced.
    *
-   * For an error to be traced, at least one of the transaction or the error
-   * must be present.
+   * For an error to be traced, at least one of the transaction or the error must be present.
    *
    * NOTE: this interface is unofficial and may change in future.
    *
-   * @param {?Transaction} transaction
-   *  Transaction associated with the error.
-   *
-   * @param {?Error} exception
-   *  The error to be traced.
-   *
-   * @param {?object} customAttributes
-   *  Any custom attributes associated with the request.
-   *
-   * @param {number} timestamp
-   *
-   * @return {bool} True if the error was collected.
+   * @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.
    */
-  _collect(transaction, exception, customAttributes, timestamp) {
-    if (exception) {
-      if (this._haveSeen(transaction, exception)) {
+  collect(transaction, exception) {
+    if (!exception) {
+      exception = new Exception({})
+    }
+
+    if (exception.error) {
+      if (this._haveSeen(transaction, exception.error)) {
         return false
       }
 
-      if (typeof exception !== 'string' && !exception.message && !exception.stack) {
-        logger.trace(exception, 'Got error that is not an instance of Error or string.')
-        exception = null
+      const error = exception.error
+      if (typeof error !== 'string' && !error.message && !error.stack) {
+        logger.trace(error, 'Got error that is not an instance of Error or string.')
+        exception.error = null
       }
     }
 
-    if (!exception && (!transaction || !transaction.statusCode || transaction.error)) {
+    if (!exception.error && (!transaction || !transaction.statusCode || transaction.error)) {
       return false
     }
 
@@ -321,13 +282,13 @@ class ErrorCollector {
       return false
     }
 
-    if (exception) {
-      logger.trace(exception, 'Got exception to trace:')
+    if (exception.error) {
+      logger.trace(exception.error, 'Got exception to trace:')
     }
 
-    const error = createError(transaction, exception, customAttributes, this.config)
+    const errorTrace = createError(transaction, exception, this.config)
 
-    const isExpectedError = true === error[4].intrinsics['error.expected']
+    const isExpectedError = true === errorTrace[4].intrinsics['error.expected']
 
     if (isExpectedError) {
       this.metrics.getOrCreateMetric(NAMES.ERRORS.EXPECTED).incrementCallCount()
@@ -343,11 +304,11 @@ class ErrorCollector {
       }
     }
 
-    this.traceAggregator.add(error)
+    this.traceAggregator.add(errorTrace)
 
     if (this.config.error_collector.capture_events === true) {
       const priority = transaction && transaction.priority || Math.random()
-      const event = createEvent(transaction, error, timestamp, this.config)
+      const event = createEvent(transaction, errorTrace, exception.timestamp, this.config)
       this.eventAggregator.add(event, priority)
     }
 

package/lib/errors/helper.js

@@ -48,7 +48,7 @@ module.exports = {
 
   extractErrorInformation: function extractErrorInformation(
     transaction,
-    exception,
+    error,
     config,
     urltils
   ) {
@@ -58,21 +58,21 @@ module.exports = {
 
     // String errors do not provide us with as much information to provide to the
     // user, but it is a common pattern.
-    if (typeof exception === 'string') {
-      message = exception
+    if (typeof error === 'string') {
+      message = error
     } else if (
-      exception !== null &&
-      typeof exception === 'object' &&
-      exception.message &&
+      error !== null &&
+      typeof error === 'object' &&
+      error.message &&
       !config.high_security &&
       !config.strip_exception_messages.enabled
     ) {
-      message = exception.message
+      message = error.message
 
-      if (exception.name) {
-        type = exception.name
-      } else if (exception.constructor && exception.constructor.name) {
-        type = exception.constructor.name
+      if (error.name) {
+        type = error.name
+      } else if (error.constructor && error.constructor.name) {
+        type = error.constructor.name
       }
     } else if (transaction && transaction.statusCode &&
                urltils.isError(config, transaction.statusCode)) {
@@ -95,9 +95,9 @@ module.exports = {
     }
   },
 
-  shouldIgnoreError: function shouldIgnoreError(transaction, exception, config) {
+  shouldIgnoreError: function shouldIgnoreError(transaction, error, config) {
     // extract _just_ the error information, not transaction stuff
-    let errorInfo = this.extractErrorInformation(null, exception, config, null)
+    let errorInfo = this.extractErrorInformation(null, error, config, null)
 
     return this.shouldIgnoreErrorClass(errorInfo, config) ||
       this.shouldIgnoreErrorMessage(errorInfo, config) ||