newrelic 9.4.0 → 9.6.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/index.js

@@ -8,7 +8,7 @@
 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 +22,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 +35,10 @@ 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 exists = fs.existsSync || path.existsSync
+const exists = fs.existsSync
 let logger = null // Lazy-loaded in `initialize`.
 let _configInstance = null
 
@@ -56,35 +57,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 +117,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 = ''
 
@@ -1057,66 +1024,77 @@ 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
+  const envKey = `NEW_RELIC_${path.toUpperCase()}${key.toUpperCase()}`
+  return envKey
+}
 
-  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/instrumentation/@hapi/hapi.js

@@ -5,4 +5,232 @@
 
 'use strict'
 
-module.exports = require('../hapi')
+const record = require('../../metrics/recorders/generic')
+// This object defines all the events that we want to wrap extensions
+// for, as they are the only ones associated with requests.
+const ROUTE_EVENTS = {
+  onRequest: true,
+  onPreAuth: true,
+  onCredentials: true,
+  onPostAuth: true,
+  onPreHandler: true,
+  onPostHandler: true,
+  onPreResponse: true,
+
+  // Server events
+  onPreStart: false,
+  onPostStart: false,
+  onPreStop: false,
+  onPostStop: false
+}
+
+module.exports = function initialize(agent, hapi, moduleName, shim) {
+  if (!agent || !hapi || !shim) {
+    shim &&
+      shim.logger.debug(
+        'Hapi instrumentation function called with incorrect arguments, not instrumenting.'
+      )
+    return false
+  }
+
+  shim.setFramework(shim.HAPI)
+
+  shim.setErrorPredicate(function hapiErrorPredicate(err) {
+    return err instanceof Error
+  })
+
+  // At this point, framework and error predicate have both already been set via ./hapi,
+  // so we only need to set the response predicate and wrap the server object
+  shim.setResponsePredicate(function hapiResponsePredicate(args, result) {
+    return !(result instanceof Error) && result !== args[1].continue
+  })
+
+  // 'Server' and 'server' both point to the same export,
+  // but we can't make any assumption about which will be used.
+  // Since we wrap the prototype, the second wrap should exit early.
+  shim.wrapReturn(hapi, 'server', serverFactoryWrapper)
+  shim.wrapReturn(hapi, 'Server', serverFactoryWrapper)
+}
+
+function serverFactoryWrapper(shim, fn, fnName, server) {
+  serverPostConstructor.call(server, shim)
+}
+
+function serverPostConstructor(shim) {
+  const proto = Object.getPrototypeOf(this)
+
+  if (shim.isWrapped(proto.decorate)) {
+    shim.logger.trace('Already wrapped Server proto, not wrapping again')
+    return
+  }
+
+  shim.wrap(proto, 'decorate', function wrapDecorate(shim, original) {
+    return function wrappedDecorate(type) {
+      // server.decorate also accepts 'request', 'toolkit', 'server' types,
+      // but we're only concerned with 'handler'
+      if (type !== 'handler') {
+        return original.apply(this, arguments)
+      }
+
+      // Convert arguments to usable array
+      const args = shim.argsToArray.apply(shim, arguments)
+
+      // Wrap the third server.decorate arg, the user-defined handler
+      shim.wrap(args, shim.THIRD, function wrapHandler(shim, fn) {
+        if (typeof fn !== 'function') {
+          return
+        }
+
+        if (fn.defaults) {
+          wrappedHandler.defaults = fn.defaults
+        }
+
+        return wrappedHandler
+
+        function wrappedHandler(route) {
+          const ret = fn.apply(this, arguments)
+
+          return typeof ret === 'function' ? wrapRouteHandler(shim, ret, route && route.path) : ret
+        }
+      })
+
+      return original.apply(this, args)
+    }
+  })
+
+  shim.wrap(proto, 'route', function wrapRoute(shim, original) {
+    return function wrappedRoute() {
+      const args = shim.argsToArray.apply(shim, arguments)
+
+      if (!shim.isObject(args[0])) {
+        return original.apply(this, args)
+      }
+
+      // If route is created via a plugin, pull prefix if it exists
+      const prefix =
+        (this.realm &&
+          this.realm.modifiers &&
+          this.realm.modifiers.route &&
+          this.realm.modifiers.route.prefix) ||
+        ''
+
+      _wrapRoute(shim, args[0])
+
+      return original.apply(this, args)
+
+      function _wrapRoute(shim, route) {
+        const routePath = prefix + route.path
+        if (shim.isArray(route)) {
+          for (let i = 0; i < route.length; ++i) {
+            _wrapRoute(shim, route[i])
+          }
+          return
+        } else if (route.options) {
+          // v17 now prefers `options` property...
+          if (route.options.pre) {
+            // config objects can also contain multiple OTHER handlers in a `pre` array
+            route.options.pre = wrapPreHandlers(shim, route.options.pre, routePath)
+          }
+          if (route.options.handler) {
+            _wrapRouteHandler(shim, route.options, routePath)
+            return
+          }
+        } else if (route.config) {
+          // ... but `config` still works
+          if (route.config.pre) {
+            route.config.pre = wrapPreHandlers(shim, route.config.pre, routePath)
+          }
+          if (route.config.handler) {
+            _wrapRouteHandler(shim, route.config, routePath)
+            return
+          }
+        }
+        _wrapRouteHandler(shim, route, routePath)
+      }
+
+      function _wrapRouteHandler(shim, container, path) {
+        if (typeof container.handler !== 'function') {
+          return
+        }
+        shim.wrap(container, 'handler', function wrapHandler(shim, handler) {
+          return wrapRouteHandler(shim, handler, path)
+        })
+      }
+    }
+  })
+
+  shim.wrap(proto, 'ext', function wrapExt(shim, original) {
+    return function wrappedExt(event, method) {
+      const args = shim.argsToArray.apply(shim, arguments)
+
+      if (shim.isArray(event)) {
+        for (let i = 0; i < event.length; i++) {
+          event[i].method = wrapMiddleware(shim, event[i].method, event[i].type)
+        }
+      } else if (shim.isObject(event)) {
+        event.method = wrapMiddleware(shim, event.method, event.type)
+      } else if (shim.isString(event)) {
+        args[1] = wrapMiddleware(shim, method, event)
+      } else {
+        shim.logger.debug('Unsupported event type %j', event)
+        return
+      }
+
+      return original.apply(this, args)
+    }
+  })
+}
+
+function wrapPreHandlers(shim, container, path) {
+  if (shim.isArray(container)) {
+    for (let i = 0; i < container.length; ++i) {
+      container[i] = wrapPreHandlers(shim, container[i], path)
+    }
+    return container
+  } else if (shim.isFunction(container)) {
+    return wrapPreHandler(shim, container, path)
+  } else if (container.method && shim.isFunction(container.method)) {
+    return shim.wrap(container, 'method', function wrapHandler(shim, handler) {
+      return wrapPreHandler(shim, handler, path)
+    })
+  }
+}
+
+function wrapPreHandler(shim, container, path) {
+  return shim.record(container, (shim) => {
+    return { name: [shim.HAPI, ' pre handler: ', '(', path, ')'].join(''), recorder: record }
+  })
+}
+
+function wrapRouteHandler(shim, handler, path) {
+  return shim.recordMiddleware(handler, {
+    route: path,
+    req: function getReq(shim, fn, fnName, args) {
+      const request = args[0]
+      if (request && request.raw) {
+        return request.raw.req
+      }
+    },
+    promise: true,
+    params: function getParams(shim, fn, fnName, args) {
+      const req = args[0]
+      return req && req.params
+    }
+  })
+}
+
+function wrapMiddleware(shim, middleware, event) {
+  if (!ROUTE_EVENTS[event]) {
+    return middleware
+  }
+
+  return shim.recordMiddleware(middleware, {
+    route: event,
+    type: event === 'onPreResponse' ? shim.ERRORWARE : shim.MIDDLEWARE,
+    promise: true,
+    req: function getReq(shim, fn, fnName, args) {
+      const req = args[0]
+      return req && req.raw && req.raw.req
+    }
+  })
+}

package/lib/instrumentation/core/async_hooks.js

@@ -38,7 +38,7 @@ function initialize(agent, shim) {
 
 function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
   const hooks = {
-    init: function initHook(id, type, triggerId, asyncResource) {
+    init: function initHook(id, type, triggerId) {
       if (type !== 'PROMISE') {
         return
       }
@@ -55,9 +55,6 @@ function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
       }
 
       const activeSegment = shim.getActiveSegment() || parentSegment
-      if (asyncResource && asyncResource.promise) {
-        asyncResource.promise.__NR_id = id
-      }
 
       segmentMap.set(id, activeSegment)
     },

package/lib/instrumentation/core/globals.js

@@ -6,6 +6,7 @@
 'use strict'
 
 const asyncHooks = require('./async_hooks')
+const symbols = require('../../symbols')
 
 module.exports = initialize
 
@@ -40,9 +41,7 @@ function initialize(agent, nodule, name, shim) {
       if (ev === 'unhandledRejection' && error && !process.domain) {
         if (process.listenerCount('unhandledRejection') === 0) {
           // If there are no unhandledRejection handlers report the error.
-          const segment = promise.__NR_id
-            ? asyncHooks.segmentMap.get(promise.__NR_id)
-            : promise.__NR_context && promise.__NR_context.getSegment()
+          const segment = promise[symbols.context] && promise[symbols.context].getSegment()
           const tx = segment && segment.transaction
           shim.logger.trace('Captured unhandled rejection for transaction %s', tx && tx.id)
           agent.errors.add(tx, error)

package/lib/instrumentation/core/http-outbound.js

@@ -12,9 +12,9 @@ const logger = require('../../logger').child({ component: 'outbound' })
 const shimmer = require('../../shimmer')
 const url = require('url')
 const copy = require('../../util/copy')
+const symbols = require('../../symbols')
 
 const NAMES = require('../../metrics/names')
-const SHIM_SYMBOLS = require('../../shim/constants').SYMBOLS
 
 const DEFAULT_HOST = 'localhost'
 const DEFAULT_HTTP_PORT = 80
@@ -85,7 +85,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
 
     // TODO: abstract header logic shared with TransactionShim#insertCATRequestHeaders
     if (agent.config.distributed_tracing.enabled) {
-      if (opts.headers && opts.headers[SHIM_SYMBOLS.DISABLE_DT]) {
+      if (opts.headers && opts.headers[symbols.disableDT]) {
         logger.trace('Distributed tracing disabled by instrumentation.')
       } else {
         transaction.insertDistributedTraceHeaders(outboundHeaders)
@@ -113,9 +113,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
     const parsed = urltils.scrubAndParseParameters(request.path)
     const proto = parsed.protocol || opts.protocol || 'http:'
     segment.name += parsed.path
-    Object.defineProperty(request, '__NR_segment', {
-      value: segment
-    })
+    request[symbols.segment] = segment
 
     if (parsed.parameters) {
       // Scrub and parse returns on object with a null prototype.