newrelic 9.5.0 → 9.7.0

package/lib/config/formatters.js

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const formatters = module.exports
+
+/**
+ * Splits a string by a ',' and trims whitespace
+ *
+ * @param {string} val config setting
+ * @param {Array}
+ */
+formatters.array = function array(val) {
+  return val.split(',').map((k) => k.trim())
+}
+
+/**
+ * Parses a config setting as an int
+ *
+ * @param {string} val config setting
+ * @returns {int}
+ */
+formatters.int = function int(val) {
+  return parseInt(val, 10)
+}
+
+/**
+ * Parses a config setting as a float
+ *
+ * @param {string} val config setting
+ * @returns {float}
+ */
+formatters.float = function float(val) {
+  return parseFloat(val, 10)
+}
+
+/**
+ * Parses a config setting as a boolean
+ *
+ * @param {string} val config setting
+ * @param setting
+ * @returns {boolean}
+ */
+formatters.boolean = function boolean(setting) {
+  if (setting == null) {
+    return false
+  }
+
+  const normalized = setting.toString().toLowerCase()
+  switch (normalized) {
+    case 'false':
+    case 'f':
+    case 'no':
+    case 'n':
+    case 'disabled':
+    case '0':
+      return false
+
+    default:
+      return true
+  }
+}
+
+/**
+ * Parses a config setting as an object
+ *
+ * @param {string} val config setting
+ * @param {logger} logger agent logger instance
+ * @returns {object}
+ */
+formatters.object = function object(val, logger) {
+  try {
+    return JSON.parse(val)
+  } catch (error) {
+    logger.error('New Relic configurator could not deserialize object:')
+    logger.error(error.stack)
+  }
+}
+
+/**
+ * Parse a config setting as a collection with 1 object
+ *
+ * @param {string} val config setting
+ * @param {logger} logger agent logger instance
+ * @returns {Array}
+ */
+formatters.objectList = function objectList(val, logger) {
+  try {
+    return JSON.parse('[' + val + ']')
+  } catch (error) {
+    logger.error('New Relic configurator could not deserialize object list:')
+    logger.error(error.stack)
+  }
+}
+
+/**
+ * Checks if a value is within an allow list. If not it assigns
+ * the first element in allow list as default
+ *
+ * @param {Array} list allowable values
+ * @param {string} val config setting
+ * @returns {string}
+ */
+formatters.allowList = function allowList(list, val) {
+  return list.includes(val) ? val : list[0]
+}

package/lib/config/harvest-config-validator.js

@@ -12,17 +12,15 @@ function isValidHarvestConfig(harvestConfig) {
 
   const harvestLimits = harvestConfig.harvest_limits
 
-  const isValid =
+  return (
     isValidHarvestValue(harvestConfig.report_period_ms) &&
     harvestLimits != null &&
     Object.keys(harvestLimits).length > 0
-
-  return isValid
+  )
 }
 
 function isValidHarvestValue(value) {
-  const isValid = value != null && value >= 0
-  return !!isValid
+  return !!(value != null && value >= 0)
 }
 
 module.exports = {

package/lib/config/index.js

@@ -5,10 +5,13 @@
 
 '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')
-const defaultConfig = require('./default').config
+const { config: defaultConfig, definition, setNestedKey } = require('./default')
 const EventEmitter = require('events').EventEmitter
 const featureFlag = require('../feature_flags')
 const flatten = require('../util/flatten')
@@ -22,6 +25,8 @@ const util = require('util')
 const MergeServerConfig = require('./merge-server-config')
 const harvestConfigValidator = require('./harvest-config-validator')
 const mergeServerConfig = new MergeServerConfig()
+const { boolean: isTruthular } = require('./formatters')
+const configDefinition = definition()
 
 /**
  * CONSTANTS -- we gotta lotta 'em
@@ -33,11 +38,11 @@ const BASE_CONFIG_PATH = require.resolve('../../newrelic')
 const HAS_ARBITRARY_KEYS = new Set(['ignore_messages', 'expected_messages', 'labels'])
 
 const LASP_MAP = require('./lasp').LASP_MAP
-const ENV = require('./env')
 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 exists = fs.existsSync || path.existsSync
+const exists = fs.existsSync
 let logger = null // Lazy-loaded in `initialize`.
 let _configInstance = null
 
@@ -56,35 +61,6 @@ const getConfigFileLocations = () =>
       : undefined
   ].filter(Boolean)
 
-function isTruthular(setting) {
-  if (setting == null) {
-    return false
-  }
-
-  const normalized = setting.toString().toLowerCase()
-  switch (normalized) {
-    case 'false':
-    case 'f':
-    case 'no':
-    case 'n':
-    case 'disabled':
-    case '0':
-      return false
-
-    default:
-      return true
-  }
-}
-
-function fromObjectList(setting) {
-  try {
-    return JSON.parse('[' + setting + ']')
-  } catch (error) {
-    logger.error('New Relic configurator could not deserialize object list:')
-    logger.error(error.stack)
-  }
-}
-
 function _findConfigFile() {
   const configFileCandidates = getConfigFileLocations().reduce((files, configPath) => {
     const configFiles = getConfigFileNames().map((filename) =>
@@ -145,11 +121,6 @@ function Config(config) {
   this.collect_errors = true
   this.collect_span_events = true
 
-  // override options for utilization stats
-  this.utilization.logical_processors = null
-  this.utilization.total_ram_mib = null
-  this.utilization.billing_hostname = null
-
   this.browser_monitoring.loader = 'rum'
   this.browser_monitoring.loader_version = ''
 
@@ -338,7 +309,7 @@ Config.prototype._fromServer = function _fromServer(params, key) {
 
     case 'ssl':
       if (!isTruthular(params.ssl)) {
-        logger.warn('SSL config key can no longer be disabled, not updating.')
+        logger.warn(SSL_WARNING)
       }
       break
 
@@ -996,7 +967,7 @@ Config.prototype._fromPassed = function _fromPassed(external, internal, arbitrar
     }
 
     if (key === 'ssl' && !isTruthular(external.ssl)) {
-      logger.warn('SSL config key can no longer be disabled, not updating.')
+      logger.warn(SSL_WARNING)
       return
     }
 
@@ -1057,66 +1028,76 @@ Config.prototype._featureFlagsFromEnv = function _featureFlagsFromEnv() {
 }
 
 /**
- * Recursively visit the nodes of the constant containing the mapping between
- * environment variable names, overriding any configuration values that are
- * found in the environment. Operates purely via side effects.
+ * Creates an env var mapper from the configuration path value
  *
- * @param object metadata The current level of the mapping object. Should never
- *                        need to set this yourself.
- * @param object data     The current level of the configuration object. Should
- *                        never need to set this yourself.
- * @param metadata
- * @param data
+ * @param {string} key of configuration value
+ * @param {Array} paths list of leaf nodes leading to configuration value
+ * @returns {string} formatted env var name
  */
-Config.prototype._fromEnvironment = function _fromEnvironment(metadata, data) {
-  if (!metadata) {
-    metadata = ENV.ENV_MAPPING
-  }
-  if (!data) {
-    data = this
-  }
+function deriveEnvVar(key, paths) {
+  let path = paths.join('_')
+  path = path ? `${path}_` : path
+  return `NEW_RELIC_${path.toUpperCase()}${key.toUpperCase()}`
+}
 
-  Object.keys(metadata).forEach(function applyEnvDefault(value) {
-    // if it's not in the config, it doesn't exist
-    if (data[value] === undefined) {
-      return
-    }
+/**
+ * Assigns the value of an env var to its corresponding configuration path
+ *
+ * @param {object} params
+ * @param {object} params.config agent config
+ * @param {string} params.key key to assign value
+ * @param {string} params.envVar name of env var
+ * @param {Function} params.formatter function to coerce env var as they are all strings
+ * @param {Array} params.paths list of leaf nodes leading to the configuration value
+ */
+function setFromEnv({ config, key, envVar, formatter, paths }) {
+  const setting = process.env[envVar]
+  if (setting) {
+    const formattedSetting = formatter ? formatter(setting, logger) : setting
+    setNestedKey(config, [...paths, key], formattedSetting)
+  }
+}
 
-    const node = metadata[value]
-    if (typeof node === 'string') {
-      const setting = process.env[node]
-      if (setting) {
-        logger.debug(`${node} environment variable set.`)
-
-        if (ENV.LIST_VARS.has(node)) {
-          const split = ENV.LIST_VARS_CUSTOM_DELIMITERS[node] || /,/
-          data[value] = setting.split(split).map(function trimVal(k) {
-            return k.trim()
-          })
-        } else if (ENV.OBJECT_LIST_VARS.has(node)) {
-          data[value] = fromObjectList(setting)
-        } else if (ENV.BOOLEAN_VARS.has(node)) {
-          if (value === 'ssl' && !isTruthular(setting)) {
-            logger.warn('SSL config key can no longer be disabled, not updating.')
-            return
-          }
-          data[value] = isTruthular(setting)
-        } else if (ENV.FLOAT_VARS.has(node)) {
-          data[value] = parseFloat(setting, 10)
-        } else if (ENV.INT_VARS.has(node)) {
-          data[value] = parseInt(setting, 10)
-        } else {
-          data[value] = setting
-        }
-      }
-    } else {
-      // don't crash if the mapping has config keys the current config doesn't.
-      if (!data[value]) {
-        data[value] = Object.create(null)
+/**
+ * Recursively visit the nodes of the config definition and look for environment variable names, overriding any configuration values that are found.
+ *
+ * @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
+ */
+Config.prototype._fromEnvironment = function _fromEnvironment(
+  config = this,
+  data = configDefinition,
+  paths = [],
+  objectKeys = 1
+) {
+  let keysSeen = 0
+  Object.entries(data).forEach(([key, value]) => {
+    const type = typeof value
+    keysSeen++
+    if (type === 'string') {
+      const envVar = deriveEnvVar(key, paths)
+      setFromEnv({ config, key, envVar, paths })
+    } else if (type === 'object') {
+      if (value.hasOwnProperty('env')) {
+        setFromEnv({ config, key, envVar: value.env, paths, formatter: value.formatter })
+      } else if (value.hasOwnProperty('default')) {
+        const envVar = deriveEnvVar(key, paths)
+        setFromEnv({ config, key, envVar, formatter: value.formatter, paths })
+      } else {
+        paths.push(key)
+        const { length } = Object.keys(value)
+        this._fromEnvironment(config, value, paths, length)
       }
-      this._fromEnvironment(node, data[value])
     }
-  }, this)
+  })
+
+  // we have traversed every key in current object leaf node, remove wrapping key
+  // to properly derive env vars of future leaf nodes
+  if (keysSeen === objectKeys) {
+    paths.pop()
+  }
 }
 
 /**

package/lib/environment.js

@@ -10,6 +10,7 @@ const { fsPromises } = require('./util/unwrapped-core')
 const os = require('os')
 const logger = require('./logger').child({ component: 'environment' })
 const stringify = require('json-stringify-safe')
+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
@@ -418,7 +419,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 +438,7 @@ function refreshSyncOnly() {
 
   if (dispatcherVersion.length) {
     dispatcher.forEach(function addDispatchers(d) {
-      addSetting('Dispatcher Version', d)
+      addSetting(DISPATCHER_VERSION, d)
     })
   }
 
@@ -503,12 +504,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 +521,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

@@ -5,6 +5,8 @@
 
 'use strict'
 
+/* eslint sonarjs/cognitive-complexity: ["error", 25] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
 const errorsModule = require('./index')
 
 const logger = require('../logger').child({ component: 'error_tracer' })
@@ -112,8 +114,7 @@ class ErrorCollector {
    * possible.
    *
    * @param {Transaction} transaction
-   *
-   * @return {number} The number of unexpected errors
+   * @returns {number} The number of unexpected errors
    */
   onTransactionFinished(transaction) {
     if (!transaction) {
@@ -226,6 +227,8 @@ class ErrorCollector {
    *
    * @param {?Transaction}  transaction  Transaction associated with the error.
    * @param {Exception}  exception The Exception to be traced.
+   * @param error
+   * @param customAttributes
    */
   addUserError(transaction, error, customAttributes) {
     if (!error) {
@@ -260,7 +263,7 @@ 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  {bool}  True if the error was collected.
    */
   collect(transaction, exception) {
     if (!exception) {

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

@@ -5,11 +5,14 @@
 
 'use strict'
 
+/* eslint sonarjs/cognitive-complexity: ["error", 22] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
+
 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 ERROR_EXPECTED_PATH = 'error.expected'
 
 class Exception {
   constructor({ error, timestamp, customAttributes, agentAttributes }) {
@@ -101,9 +104,9 @@ function createError(transaction, exception, config) {
     }
   }
 
-  params.intrinsics['error.expected'] = false
+  params.intrinsics[ERROR_EXPECTED_PATH] = false
   if (errorHelper.isExpected(type, message, transaction, config, urltils)) {
-    params.intrinsics['error.expected'] = true
+    params.intrinsics[ERROR_EXPECTED_PATH] = true
   }
 
   const res = [0, name, message, type, params]
@@ -116,6 +119,11 @@ function createError(transaction, exception, config) {
 /**
  * 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
+ * @param error
+ * @param timestamp
+ * @param config
  */
 function createEvent(transaction, error, timestamp, config) {
   const message = error[2]
@@ -126,7 +134,7 @@ function createEvent(transaction, error, timestamp, config) {
     transaction,
     errorClass,
     message,
-    errorParams.intrinsics['error.expected'],
+    errorParams.intrinsics[ERROR_EXPECTED_PATH],
     timestamp,
     config
   )
@@ -136,9 +144,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

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) {

package/lib/header-processing.js

@@ -14,6 +14,7 @@ const CONTENT_LENGTH_REGEX = /^Content-Length$/i
  *
  * Queue time is provided by certain providers by stamping the request
  * header with the time the request arrived at the router.
+ *
  * @param {*} logger
  * @param {*} requestHeaders
  */
@@ -37,8 +38,7 @@ function getQueueTime(logger, requestHeaders) {
     return null
   }
 
-  const convertedQueueTime = convertUnit(parsedQueueTime)
-  return convertedQueueTime
+  return convertUnit(parsedQueueTime)
 }
 
 function convertUnit(time) {