newrelic 9.7.0 → 9.7.2

package/lib/config/index.js

@@ -5,9 +5,6 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 29] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-/* eslint sonarjs/max-switch-cases: ["error", 36] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
 const AttributeFilter = require('./attribute-filter')
 const CollectorResponse = require('../collector/response')
 const copy = require('../util/copy')
@@ -41,6 +38,7 @@ const LASP_MAP = require('./lasp').LASP_MAP
 const HSM = require('./hsm')
 const REMOVE_BEFORE_SEND = new Set(['attributeFilter'])
 const SSL_WARNING = 'SSL config key can no longer be disabled, not updating.'
+const SERVERLESS_DT_KEYS = ['account_id', 'primary_application_id', 'trusted_account_key']
 
 const exists = fs.existsSync
 let logger = null // Lazy-loaded in `initialize`.
@@ -200,7 +198,7 @@ Config.prototype.mergeServerConfig = mergeServerConfig
  * recognized, unsupported, and unknown parameters.
  *
  * @param {object} json The config blob sent by New Relic.
- * @param recursion
+ * @param {boolean} recursion flag indicating coming from server side config
  */
 Config.prototype.onConnect = function onConnect(json, recursion) {
   json = json || Object.create(null)
@@ -233,6 +231,49 @@ Config.prototype._getMostSecure = function getMostSecure(key, currentVal, newVal
   return filter(currentVal, newVal)
 }
 
+/**
+ * Helper that checks if value from server is false
+ * then updates the corresponding configuration enabled flag.
+ * We never allow server-side config to enable a feature but you can disable
+ *
+ * @param {*} serverValue value from server
+ * @param {string} key within configuration to disable its enabled flag
+ */
+Config.prototype._disableOption = function _disableOption(serverValue, key) {
+  if (serverValue === false) {
+    this[key].enabled = false
+  }
+}
+
+/**
+ * Updates harvest_limits for event_harvest_config if they are valid values
+ *
+ * @param {object} serverConfig harvest config from server
+ * @param {string} key value from server side config that stores the event harvest config
+ */
+Config.prototype._updateHarvestConfig = function _updateHarvestConfig(serverConfig, key) {
+  const val = serverConfig[key]
+  const isValidConfig = harvestConfigValidator.isValidHarvestConfig(val)
+  if (!isValidConfig) {
+    this.emit(key, null)
+    return
+  }
+
+  logger.info('Valid event_harvest_config received. Updating harvest cycles.', val)
+  const limits = Object.keys(val.harvest_limits).reduce((acc, k) => {
+    const v = val.harvest_limits[k]
+    if (harvestConfigValidator.isValidHarvestValue(v)) {
+      acc[k] = v
+    } else {
+      logger.info(`Omitting limit for ${k} due to invalid value ${v}`)
+    }
+    return acc
+  }, {})
+  val.harvest_limits = limits
+  this[key] = val
+  this.emit(key, val)
+}
+
 /**
  * The guts of the logic about how to deal with server-side configuration.
  *
@@ -240,6 +281,7 @@ Config.prototype._getMostSecure = function getMostSecure(key, currentVal, newVal
  * @param {string} key    The particular configuration parameter to set.
  */
 Config.prototype._fromServer = function _fromServer(params, key) {
+  /* eslint-disable-next-line sonarjs/max-switch-cases */
   switch (key) {
     // handled by the connection
     case 'messages':
@@ -318,49 +360,19 @@ Config.prototype._fromServer = function _fromServer(params, key) {
       this._updateIfChanged(params, key)
       break
     case 'event_harvest_config':
-      const val = params[key]
-      const isValidConfig = harvestConfigValidator.isValidHarvestConfig(val)
-      if (!isValidConfig) {
-        this.emit(key, null)
-        break
-      }
-      logger.info('Valid event_harvest_config received. Updating harvest cycles.', val)
-      const limits = Object.keys(val.harvest_limits).reduce((acc, k) => {
-        const v = val.harvest_limits[k]
-        if (harvestConfigValidator.isValidHarvestValue(v)) {
-          acc[k] = v
-        } else {
-          logger.info(`Omitting limit for ${k} due to invalid value ${v}`)
-        }
-        return acc
-      }, {})
-      val.harvest_limits = limits
-      this[key] = val
-      this.emit(key, val)
+      this._updateHarvestConfig(params, key)
       break
 
     case 'collect_analytics_events':
-      // never enable from server-side
-      // but we allow the server to disable
-      if (params.collect_analytics_events === false) {
-        this.transaction_events.enabled = false
-      }
+      this._disableOption(params.collect_analytics_events, 'transaction_events')
       break
 
     case 'collect_custom_events':
-      // never enable from server-side
-      // but we allow the server to disable
-      if (params.collect_custom_events === false) {
-        this.custom_insights_events.enabled = false
-      }
+      this._disableOption(params.collect_custom_events, 'custom_insights_events')
       break
 
     case 'collect_span_events':
-      // never enable from server-side
-      // but we allow the server to disable
-      if (params.collect_span_events === false) {
-        this.span_events.enabled = false
-      }
+      this._disableOption(params.collect_span_events, 'span_events')
       break
 
     case 'allow_all_headers':
@@ -930,6 +942,8 @@ function getHostnameSafe() {
 
 /**
  * Ensure that the apps names are always returned as a list.
+ *
+ * @returns {Array} list of applications
  */
 Config.prototype.applications = function applications() {
   const apps = this.app_name
@@ -950,7 +964,7 @@ Config.prototype.applications = function applications() {
  *
  * @param {object} external The configuration being loaded.
  * @param {object} internal Whichever chunk of the config being overridden.
- * @param arbitrary
+ * @param {boolean} arbitrary flag indicating if it is in the HAS_ARBITRARY_KEYS set
  */
 Config.prototype._fromPassed = function _fromPassed(external, internal, arbitrary) {
   if (!external) {
@@ -1035,15 +1049,15 @@ Config.prototype._featureFlagsFromEnv = function _featureFlagsFromEnv() {
  * @returns {string} formatted env var name
  */
 function deriveEnvVar(key, paths) {
-  let path = paths.join('_')
-  path = path ? `${path}_` : path
-  return `NEW_RELIC_${path.toUpperCase()}${key.toUpperCase()}`
+  let configPath = paths.join('_')
+  configPath = configPath ? `${configPath}_` : configPath
+  return `NEW_RELIC_${configPath.toUpperCase()}${key.toUpperCase()}`
 }
 
 /**
  * Assigns the value of an env var to its corresponding configuration path
  *
- * @param {object} params
+ * @param {object} params object passed to fn
  * @param {object} params.config agent config
  * @param {string} params.key key to assign value
  * @param {string} params.envVar name of env var
@@ -1064,7 +1078,7 @@ function setFromEnv({ config, key, envVar, formatter, paths }) {
  * @param {object} [config=this] The current level of the configuration object.
  * @param {object} [data=configDefinition] The current level of the config definition object.
  * @param {Array} [paths=[]] keeps track of the nested path to properly derive the env var
- * @param {int} [objectKeys=1] indicator of how many keys exist in current node to know when to remove current node after all keys are processed
+ * @param {number} [objectKeys=1] indicator of how many keys exist in current node to know when to remove current node after all keys are processed
  */
 Config.prototype._fromEnvironment = function _fromEnvironment(
   config = this,
@@ -1101,144 +1115,131 @@ Config.prototype._fromEnvironment = function _fromEnvironment(
 }
 
 /**
- * Returns true if logging has been manually enabled via configuration file or
- * environment variable.
+ * Disables `logging.enabled` if not set in configuration file or environment variable.
  *
  * @param {*} inputConfig configuration passed to the Config constructor
- * @returns {boolean}
+ * @returns {void}
  */
-Config.prototype._loggingManuallySet = function _loggingManuallySet(inputConfig) {
-  const inputEnabled = inputConfig && inputConfig.logging && inputConfig.logging.enabled
+Config.prototype._serverlessLogging = function _serverlessLogging(inputConfig) {
+  const inputEnabled = inputConfig?.logging?.enabled
   const envEnabled = process.env.NEW_RELIC_LOG_ENABLED
 
-  return inputEnabled !== undefined || envEnabled !== undefined
+  if (inputEnabled === undefined && envEnabled === undefined) {
+    this.logging.enabled = false
+
+    logger.info(
+      'Logging is disabled by default when serverless_mode is enabled. ' +
+        'If desired, enable logging via config file or environment variable and ' +
+        'set filepath to a valid path for current environment, stdout or stderr.'
+    )
+  }
 }
 
 /**
  * Returns true if native-metrics has been manually enabled via configuration
- * file or enveironment variable
+ * file or environment variable
  *
  * @param {*} inputConfig configuration pass to the Config constructor
- * @returns {boolean}
+ * @returns {void}
  */
-Config.prototype._nativeMetricsManuallySet = function _nativeMetricsManuallySet(inputConfig) {
-  const inputEnabled =
-    inputConfig &&
-    inputConfig.plugins &&
-    inputConfig.plugins.native_metrics &&
-    inputConfig.plugins.native_metrics.enabled
+Config.prototype._serverlessNativeMetrics = function _serverlessNativeMetrics(inputConfig) {
+  const inputEnabled = inputConfig?.plugins?.native_metrics?.enabled
   const envEnabled = process.env.NEW_RELIC_NATIVE_METRICS_ENABLED
 
-  return inputEnabled !== undefined || envEnabled !== undefined
+  if (
+    (inputEnabled !== undefined || envEnabled !== undefined) &&
+    this.plugins.native_metrics.enabled
+  ) {
+    logger.info(
+      'Enabling the native-metrics module when in serverless mode may greatly ' +
+        'increase cold-start times. Given the limited benefit of the VM metrics' +
+        'and general lack of control in a serverless environment, we do not ' +
+        'recommend this trade-off.'
+    )
+  } else {
+    this.plugins.native_metrics.enabled = false
+
+    logger.info(
+      'The native-metrics module is disabled by default when serverless_mode ' +
+        'is enabled.  If desired, enable the native-metrics module via config file ' +
+        'or environment variable.'
+    )
+  }
 }
 
 /**
- * Returns true if distributed tracing has been manually enabled via configuration file or
- * environment variable.
+ * Application name is not currently leveraged by our Lambda product (March 2021).
+ * Defaulting the name removes burden on customers to set while avoiding
+ * breaking should it be used in the future.
  *
- * @param {*} inputConfig configuration passed to the Config constructor
- * @returns {boolean}
+ * @returns {void}
  */
-Config.prototype._DTManuallySet = function _DTManuallySet(inputConfig) {
-  const inputEnabled =
-    inputConfig && inputConfig.distributed_tracing && inputConfig.distributed_tracing.enabled
+Config.prototype._serverlessAppName = function _serverlessAppName() {
+  if (!this.app_name || this.app_name.length === 0) {
+    const namingSource = process.env.AWS_LAMBDA_FUNCTION_NAME
+      ? 'process.env.AWS_LAMBDA_FUNCTION_NAME'
+      : 'DEFAULT'
 
-  const envEnabled = process.env.NEW_RELIC_DISTRIBUTED_TRACING_ENABLED
+    const name = process.env.AWS_LAMBDA_FUNCTION_NAME || 'Serverless Application'
+    this.app_name = [name]
 
-  return inputEnabled !== undefined || envEnabled !== undefined
+    logger.info("Auto-naming serverless application to ['%s'] from: %s", name, namingSource)
+  }
 }
 
 /**
- * Enforces config rules specific to running in serverless_mode:
- *   - disables cross_application_tracer.enabled if set
- *   - defaults logging to disabled
- *   - verifies data specific to running DT is defined either in config file of env vars
- *
- * @param {*} inputConfig configuration passed to the Config constructor
+ * Disables CAT in serverless mode
  */
-Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
-  if (this.serverless_mode.enabled) {
-    // Application name is not currently leveraged by our Lambda product (March 2021).
-    // Defaulting the name removes burden on customers to set while avoiding
-    // breaking should it be used in the future.
-    if (!this.app_name || this.app_name.length === 0) {
-      const namingSource = process.env.AWS_LAMBDA_FUNCTION_NAME
-        ? 'process.env.AWS_LAMBDA_FUNCTION_NAME'
-        : 'DEFAULT'
-
-      const name = process.env.AWS_LAMBDA_FUNCTION_NAME || 'Serverless Application'
-      this.app_name = [name]
-
-      logger.info("Auto-naming serverless application to ['%s'] from: %s", name, namingSource)
-    }
-
-    // Explicitly disable old CAT in serverless_mode
-    if (this.cross_application_tracer.enabled) {
-      this.cross_application_tracer.enabled = false
-      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
-
-      logger.info(
-        'Logging is disabled by default when serverless_mode is enabled. ' +
-          'If desired, enable logging via config file or environment variable and ' +
-          'set filepath to a valid path for current environment, stdout or stderr.'
-      )
-    }
+Config.prototype._serverlessCAT = function _serverlessCAT() {
+  if (this.cross_application_tracer.enabled) {
+    this.cross_application_tracer.enabled = false
+    logger.info('Cross application tracing is explicitly disabled in serverless_mode.')
+  }
+}
 
-    if (this._nativeMetricsManuallySet(inputConfig) && this.plugins.native_metrics.enabled) {
-      logger.info(
-        'Enabling the native-metrics module when in serverless mode may greatly ' +
-          'increase cold-start times. Given the limited benefit of the VM metrics' +
-          'and general lack of control in a serverless environment, we do not ' +
-          'recommend this trade-off.'
-      )
-    } else {
-      this.plugins.native_metrics.enabled = false
+Config.prototype._serverlessInfiniteTracing = function _serverlessInfiniteTracing() {
+  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.')
+  }
+}
 
-      logger.info(
-        'The native-metrics module is disabled by default when serverless_mode ' +
-          'is enabled.  If desired, enable the native-metrics module via config file ' +
-          'or environment variable.'
+/**
+ * Disables DT if account_id is not set.
+ * Otherwise it will set trusted_account_key and primary_application_id accordingly.
+ *
+ * @returns {void}
+ */
+Config.prototype._serverlessDT = function _serverlessDT() {
+  if (!this.account_id) {
+    if (this.distributed_tracing.enabled) {
+      logger.warn(
+        'Using distributed tracing in serverless mode requires account_id be ' +
+          'defined, either in your newrelic.js file or via environment variables. ' +
+          'Disabling distributed tracing.'
       )
+      this.distributed_tracing.enabled = false
     }
-
-    if (!this._DTManuallySet(inputConfig)) {
-      this.distributed_tracing.enabled = true
-    }
-
-    if (!this.account_id) {
-      if (this.distributed_tracing.enabled) {
-        logger.warn(
-          'Using distributed tracing in serverless mode requires account_id be ' +
-            'defined, either in your newrelic.js file or via environment variables. ' +
-            'Disabling distributed tracing.'
-        )
-        this.distributed_tracing.enabled = false
-      }
-
-      return
-    }
+  } else {
     // default trusted_account_key to account_id
     this.trusted_account_key = this.trusted_account_key || this.account_id
 
     // Not required in serverless mode but must default to Unknown to function.
     this.primary_application_id = this.primary_application_id || 'Unknown'
-
-    return
   }
+}
 
-  const DT_KEYS = ['account_id', 'primary_application_id', 'trusted_account_key']
+/**
+ * In serverless mode we allow defer auth to the downstream serverless entities.
+ * This means we set account_id, primary_application_id, and trusted_account_key in configuration.
+ * This function sets all those to null because this.serverles_mode.enabled is falsey.
+ *
+ * @returns {void}
+ */
+Config.prototype._preventServerlessDT = function _preventServerlessDT() {
   // Don't allow DT config settings to be set if serverless_mode is disabled
-  DT_KEYS.forEach((key) => {
+  SERVERLESS_DT_KEYS.forEach((key) => {
     if (this[key]) {
       logger.warn(
         key +
@@ -1250,6 +1251,27 @@ Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
   })
 }
 
+/**
+ * Enforces config rules specific to running in serverless_mode:
+ *   - disables cross_application_tracer.enabled if set
+ *   - defaults logging to disabled
+ *   - verifies data specific to running DT is defined either in config file of env vars
+ *
+ * @param {*} inputConfig configuration passed to the Config constructor
+ */
+Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
+  if (this.serverless_mode.enabled) {
+    this._serverlessAppName()
+    this._serverlessCAT()
+    this._serverlessInfiniteTracing()
+    this._serverlessLogging(inputConfig)
+    this._serverlessNativeMetrics(inputConfig)
+    this._serverlessDT(inputConfig)
+  } else {
+    this._preventServerlessDT()
+  }
+}
+
 /**
  * Depending on how the status codes are set, they could be strings, which
  * makes strict equality testing / indexOf fail. To keep things cheap, parse
@@ -1290,43 +1312,57 @@ Config.prototype._canonicalize = function _canonicalize() {
   }
 }
 
-function _parseCodes(codes) {
-  // range does not support negative values
-  function parseRange(range, parsed) {
-    const split = range.split('-')
-    if (split.length !== 2) {
-      logger.warn('Failed to parse range %s', range)
-      return parsed
-    }
-    if (split[0] === '') {
-      // catch negative code. ex. -7
-      return parsed.push(parseInt(range, 10))
-    }
-    const lower = parseInt(split[0], 10)
-    const upper = parseInt(split[1], 10)
-    if (Number.isNaN(lower) || Number.isNaN(upper)) {
-      logger.warn('Range must contain two numbers %s', range)
-      return parsed
-    }
-    if (lower > upper) {
-      logger.warn('Range must start with lower bound %s', range)
-    } else if (lower < 0 || upper > 1000) {
-      logger.warn('Range must be between 0 and 1000 %s', range)
-    } else {
-      // success
-      for (let i = lower; i <= upper; i++) {
-        parsed.push(i)
-      }
-    }
+/**
+ * Splits a range of status codes. It will not
+ * allow negative values, non-numbers, or numbers above 1000.
+ *
+ * @param {string} range range of status codes 400-421
+ * @param {Array} parsed list of parsed codes
+ * @returns {Array} adds to the cleansed list of status codes
+ * by removing any ranges and adds as elements
+ */
+function _parseRange(range, parsed) {
+  const split = range.split('-')
+  if (split.length !== 2) {
+    logger.warn('Failed to parse range %s', range)
     return parsed
   }
+  if (split[0] === '') {
+    // catch negative code. ex. -7
+    return parsed.push(parseInt(range, 10))
+  }
+  const lower = parseInt(split[0], 10)
+  const upper = parseInt(split[1], 10)
+  if (Number.isNaN(lower) || Number.isNaN(upper)) {
+    logger.warn('Range must contain two numbers %s', range)
+    return parsed
+  }
+  if (lower > upper) {
+    logger.warn('Range must start with lower bound %s', range)
+  } else if (lower < 0 || upper > 1000) {
+    logger.warn('Range must be between 0 and 1000 %s', range)
+  } else {
+    // success
+    for (let i = lower; i <= upper; i++) {
+      parsed.push(i)
+    }
+  }
+  return parsed
+}
 
+/**
+ * Parses a list of status codes.  It can also
+ * parse a range of status codes
+ *
+ * @param {Array} codes list of status codes
+ * @returns {Array} cleansed list of status codes
+ */
+function _parseCodes(codes) {
   const parsedCodes = []
   for (let i = 0; i < codes.length; i++) {
     const code = codes[i]
-
     if (typeof code === 'string' && code.indexOf('-') !== -1) {
-      parseRange(code, parsedCodes)
+      _parseRange(code, parsedCodes)
     } else {
       const parsedCode = parseInt(code, 10)
       if (!Number.isNaN(parsedCode)) {
@@ -1376,30 +1412,29 @@ Config.prototype._applyHighSecurity = function _applyHighSecurity() {
 }
 
 /**
- * Checks policies received from preconnect against those expected
- * by the agent, if LASP-enabled. Responds with an error to shut down
- * the agent if necessary.
+ * Sends a response to collector for LASP application
  *
- * @param {Agent} agent
- * @param {object} policies
- * @returns {CollectorResponse} The result of the processing, with the known
- *  policies as the response payload.
+ * @param {Array} keys keys from a LASP policy
+ * @returns {CollectorResponse} creates CollectorResponse with either preserve or shutdown
  */
-Config.prototype.applyLasp = function applyLasp(agent, policies) {
-  const config = this
-  const keys = Object.keys(policies)
-
-  if (!config.security_policies_token) {
-    if (keys.length) {
-      logger.error(
-        'The agent received one or more unexpected security policies and will shut down.'
-      )
-      return CollectorResponse.fatal(null)
-    }
-    return CollectorResponse.success(null)
+function _laspReponse(keys) {
+  if (keys.length) {
+    logger.error('The agent received one or more unexpected security policies and will shut down.')
+    return CollectorResponse.fatal(null)
   }
+  return CollectorResponse.success(null)
+}
 
-  const missingLASP = []
+/**
+ * Applies the server side LASP policies to a local configuration object
+ *
+ * @param agent
+ * @param {object} policies server side LASP policy
+ * @returns {object} { missingRequired, finalPolicies } list of missing required fields and finalized LASP policy
+ */
+Config.prototype._buildLaspPolicy = function _buildLaspPolicy(agent, policies) {
+  const config = this
+  const keys = Object.keys(policies)
   const missingRequired = []
 
   const finalPolicies = keys.reduce(function applyPolicy(obj, name) {
@@ -1451,6 +1486,29 @@ Config.prototype.applyLasp = function applyLasp(agent, policies) {
     return obj
   }, Object.create(null))
 
+  return { missingRequired, finalPolicies }
+}
+
+/**
+ * Checks policies received from preconnect against those expected
+ * by the agent, if LASP-enabled. Responds with an error to shut down
+ * the agent if necessary.
+ *
+ * @param agent
+ * @param {object} policies lasp policy
+ * @returns {CollectorResponse} The result of the processing, with the known
+ *  policies as the response payload.
+ */
+Config.prototype.applyLasp = function applyLasp(agent, policies) {
+  const keys = Object.keys(policies)
+
+  if (!this.security_policies_token) {
+    return _laspReponse(keys)
+  }
+
+  const { finalPolicies, missingRequired } = this._buildLaspPolicy(agent, policies)
+
+  const missingLASP = []
   Object.keys(LASP_MAP).forEach(function checkPolicy(name) {
     if (!policies[name]) {
       // agent is expecting a policy that was not sent from server -- fail
@@ -1511,7 +1569,7 @@ function redactValue(value) {
  * Get a JSONifiable object containing all settings we want to report to the
  * collector and store in the environment_values table.
  *
- * @returns Object containing simple key-value pairs of settings
+ * @returns {object} containing simple key-value pairs of settings
  */
 Config.prototype.publicSettings = function publicSettings() {
   let settings = Object.create(null)
@@ -1586,8 +1644,8 @@ Config.prototype._warnDeprecations = function _warnDeprecations() {
  * the environment variables will override their corresponding
  * configuration file settings.
  *
- * @param {object} config Optional configuration to be used in place of a
- *                        config file.
+ * @param {object} config Optional configuration to be used in place of a config file.
+ * @returns {object} instantiated configuration object
  */
 function initialize(config) {
   /**
@@ -1660,7 +1718,8 @@ function initialize(config) {
 /**
  * This helper function creates an empty configuration object
  *
- * @param config
+ * @param {object} config current configuration object to overwrite
+ * @returns {object} config new config object
  */
 function createNewConfigObject(config) {
   config = new Config(Object.create(null))
@@ -1674,6 +1733,8 @@ function createNewConfigObject(config) {
  * This function honors the singleton nature of this module while allowing
  * consumers to just request an instance without having to worry if one was
  * already created.
+ *
+ * @returns {object} initialized configuration object
  */
 function getOrCreateInstance() {
   if (_configInstance === null) {