newrelic 9.7.0 → 9.7.2

package/lib/system-info.js

@@ -5,113 +5,192 @@
 
 'use strict'
 
-/* eslint sonarjs/cognitive-complexity: ["error", 29] -- TODO: https://issues.newrelic.com/browse/NEWRELIC-5252 */
-
-const exec = require('child_process').exec
-const readProc = require('./utilization/common').readProc
-const getBootId = require('./utilization/docker-info').getBootId
-const utilization = require('./utilization')
+const util = require('util')
+const execFile = util.promisify(require('child_process').execFile)
+const readProc = util.promisify(require('./utilization/common').readProc)
+const getBootId = util.promisify(require('./utilization/docker-info').getBootId)
+const getVendors = util.promisify(require('./utilization').getVendors)
 const logger = require('./logger.js').child({ component: 'system-info' })
 const os = require('os')
 const parseCpuInfo = require('./parse-proc-cpuinfo')
 const parseMemInfo = require('./parse-proc-meminfo')
+const Agent = require('./agent')
 const platform = os.platform()
 
 module.exports = fetchSystemInfo
 
-function isInteger(i) {
-  return i === parseInt(i, 10)
+/**
+ * Helper method for determining if given value can be an integer
+ *
+ * @param {*} value the value to check
+ * @returns {boolean} whether or not the value can be coerced to an integer
+ */
+function isInteger(value) {
+  return value === parseInt(value, 10)
 }
 
-function fetchSystemInfo(agent, callback, numTasks = 5) {
-  const config = agent.config
-  const systemInfo = {
-    processorArch: os.arch()
+/**
+ * Helper method for updating the utilization info with processor information from the config
+ *
+ * @param {*} processorConfig agent.config.utilization.logical_processors
+ * @param {object} utilizationConfig Utilization configuration object defined in #fetchSystemInfo
+ */
+function maybeAddProcessorUtilization(processorConfig, utilizationConfig) {
+  const parsedConfigProcessors = parseFloat(processorConfig, 10)
+  if (!isNaN(parsedConfigProcessors) && isInteger(parsedConfigProcessors)) {
+    utilizationConfig.logical_processors = parsedConfigProcessors
+  } else {
+    logger.info(
+      '%s supplied in config for utilization.logical_processors, expected a number',
+      processorConfig
+    )
+  }
+}
+
+/**
+ * Helper method for updating the utilization info with RAM information from the config
+ *
+ * @param {*} ramConfig agent.config.utilization.total_ram_mib
+ * @param {object} utilizationConfig Utilization configuration object defined in #fetchSystemInfo
+ */
+function maybeAddRamUtilization(ramConfig, utilizationConfig) {
+  const parsedConfigRam = parseFloat(ramConfig, 10)
+  if (!isNaN(parsedConfigRam) && isInteger(parsedConfigRam)) {
+    utilizationConfig.total_ram_mib = parsedConfigRam
+  } else {
+    logger.info('%s supplied in config for utilization.total_ram_mib, expected a number', ramConfig)
   }
+}
+
+/**
+ * Helper method for updating the utilization info with hostname information from the config
+ *
+ * @param {*} configHostname agent.config.utilization.billing_hostname
+ * @param {object} utilizationConfig Utilization configuration object defined in #fetchSystemInfo
+ */
+function maybeAddHostUtilization(configHostname, utilizationConfig) {
+  if (typeof configHostname === 'string') {
+    utilizationConfig.hostname = configHostname
+  } else {
+    logger.info('%s supplied in config for utilization.Hostname, expected a string', configHostname)
+  }
+}
 
+/**
+ * Helper method for updating the system info with architecture dependent processor info
+ *
+ * @param {*} processorStats output of #getProcessorStats
+ * @param {object} systemInfo System Information object defined in #fetchSystemInfo
+ */
+function maybeSetProcessorStats(processorStats, systemInfo) {
+  if (processorStats) {
+    systemInfo.packages = processorStats.packages
+    systemInfo.logicalProcessors = processorStats.logical
+    systemInfo.cores = processorStats.cores
+  }
+}
+
+/**
+ * Helper method for updating the system info with architecture dependent RAM info
+ *
+ * @param {*} memoryStats output of #getMemoryStats
+ * @param {object} systemInfo System Information object defined in #fetchSystemInfo
+ */
+function maybeSetMemoryStats(memoryStats, systemInfo) {
+  if (memoryStats) {
+    systemInfo.memory = memoryStats
+  }
+}
+
+/**
+ * Helper method for updating the system info with architecture dependent Kernel info
+ *
+ * @param {*} kernelStats output of #getKernelVersion
+ * @param {object} systemInfo System Information object defined in #fetchSystemInfo
+ */
+function maybeSetKernelStats(kernelStats, systemInfo) {
+  if (kernelStats) {
+    systemInfo.kernelVersion = kernelStats
+  }
+}
+
+/**
+ * Helper method for updating the system info with vendor info
+ *
+ * @param {*} vendorStats output of #utilization.getVendors
+ * @param {object} systemInfo System Information object defined in #fetchSystemInfo
+ */
+function maybeSetVendorStats(vendorStats, systemInfo) {
+  if (vendorStats) {
+    systemInfo.vendors = vendorStats
+  }
+}
+
+/**
+ * Helper method for updating the system info with the Docker boot id
+ *
+ * @param {*} bootId output of #utilization/docker-info.getBootId
+ * @param {object} systemInfo System Information object defined in #fetchSystemInfo
+ */
+function maybeSetBootId(bootId, systemInfo) {
+  if (bootId) {
+    systemInfo.bootId = bootId
+  }
+}
+
+/**
+ * Main method for retrieving system level statistics, used for fact gathering on Agent startup
+ *
+ * @param {Agent} agent Instantiation of Node.js agent
+ * @param {Function} callback Callback to fire after we've gathered all the necessary stats
+ */
+async function fetchSystemInfo(agent, callback) {
   const utilizationConfig = Object.create(null)
-  if (config.utilization) {
-    const configProcessors = config.utilization.logical_processors
-    const configRam = config.utilization.total_ram_mib
-    const configHostname = config.utilization.billing_hostname
-
-    if (configProcessors) {
-      const parsedConfigProcessors = parseFloat(configProcessors, 10)
-      if (!isNaN(parsedConfigProcessors) && isInteger(parsedConfigProcessors)) {
-        utilizationConfig.logical_processors = parsedConfigProcessors
-      } else {
-        logger.info(
-          '%s supplied in config for utilization.logical_processors, expected a number',
-          configProcessors
-        )
-      }
-    }
+  const systemInfo = {
+    processorArch: os.arch()
+  }
 
-    if (configRam) {
-      const parsedConfigRam = parseFloat(configRam, 10)
-      if (!isNaN(parsedConfigRam) && isInteger(parsedConfigRam)) {
-        utilizationConfig.total_ram_mib = parsedConfigRam
-      } else {
-        logger.info(
-          '%s supplied in config for utilization.total_ram_mib, expected a number',
-          configRam
-        )
-      }
-    }
+  const processorConfig = agent.config.utilization?.logical_processors
+  if (processorConfig) {
+    maybeAddProcessorUtilization(processorConfig, utilizationConfig)
+  }
 
-    if (configHostname) {
-      if (typeof configHostname === 'string') {
-        utilizationConfig.hostname = configHostname
-      } else {
-        logger.info(
-          '%s supplied in config for utilization.Hostname, expected a string',
-          configHostname
-        )
-      }
-    }
+  const ramConfig = agent.config.utilization?.total_ram_mib
+  if (ramConfig) {
+    maybeAddRamUtilization(ramConfig, utilizationConfig)
+  }
 
-    if (Object.keys(utilizationConfig).length > 0) {
-      systemInfo.config = utilizationConfig
-    }
+  const configHostname = agent.config.utilization?.billing_hostname
+  if (configHostname) {
+    maybeAddHostUtilization(configHostname, utilizationConfig)
   }
 
-  let tasksDone = 0
-  function finishedResponse() {
-    if (++tasksDone === numTasks) {
-      callback(null, systemInfo)
-    }
+  if (Object.keys(utilizationConfig).length > 0) {
+    systemInfo.config = utilizationConfig
   }
 
-  module.exports._getProcessorStats(function getProcessCB(processorStats) {
-    systemInfo.packages = processorStats.packages
-    systemInfo.logicalProcessors = processorStats.logical
-    systemInfo.cores = processorStats.cores
-    finishedResponse()
-  })
-  module.exports._getMemoryStats(function getMemCB(memory) {
-    systemInfo.memory = memory
-    finishedResponse()
-  })
-  getKernelVersion(function getVersionCB(kernelVersion) {
-    systemInfo.kernelVersion = kernelVersion
-    finishedResponse()
-  })
-  utilization.getVendors(agent, function getVendorInfo(err, vendors) {
-    if (vendors) {
-      systemInfo.vendors = vendors
-    }
-    finishedResponse()
-  })
-  getBootId(agent, function reportBootId(err, bootId) {
-    if (bootId) {
-      systemInfo.bootId = bootId
-    }
-    finishedResponse()
-  })
+  const processorStats = await module.exports._getProcessorStats()
+  const memoryStats = await module.exports._getMemoryStats()
+  const kernelStats = await getKernelVersion()
+  const vendorStats = await getVendors(agent)
+  const bootId = await getBootId(agent)
+
+  maybeSetProcessorStats(processorStats, systemInfo)
+  maybeSetMemoryStats(memoryStats, systemInfo)
+  maybeSetKernelStats(kernelStats, systemInfo)
+  maybeSetVendorStats(vendorStats, systemInfo)
+  maybeSetBootId(bootId, systemInfo)
+
+  callback(null, systemInfo)
 }
 
-// placed on module for mocking purposes in tests
-module.exports._getProcessorStats = function getProcessorStats(callback) {
+/**
+ * Helper method for getting detailed, architecture specific processor information from the system
+ * Exported for testing purposes
+ *
+ * @returns {*} null if unknown platform, otherwise the processor stats
+ */
+module.exports._getProcessorStats = async function getProcessorStats() {
   const processorStats = {
     logical: null,
     cores: null,
@@ -119,101 +198,99 @@ module.exports._getProcessorStats = function getProcessorStats(callback) {
   }
 
   if (platform.match(/darwin/i)) {
-    getSysctlValue(['hw.packages'], function getPackages(packages) {
-      getSysctlValue(['hw.physicalcpu_max', 'hw.physicalcpu'], function getCores(cores) {
-        getSysctlValue(
-          ['hw.logicalcpu_max', 'hw.logicalcpu', 'hw.ncpu'],
-          function getLogicalCpu(logical) {
-            processorStats.logical = parseFloat(logical, 10)
-            processorStats.cores = parseFloat(cores, 10)
-            processorStats.packages = parseFloat(packages, 10)
-
-            for (const key in processorStats) {
-              if (!processorStats[key] || !isInteger(processorStats[key])) {
-                processorStats[key] = null
-              }
-            }
-
-            callback(processorStats)
-          }
-        )
-      })
-    })
+    const packages = await getSysctlValue(['hw.packages'])
+    const cores = await getSysctlValue(['hw.physicalcpu_max', 'hw.physicalcpu'])
+    const logical = await getSysctlValue(['hw.logicalcpu_max', 'hw.logicalcpu', 'hw.ncpu'])
+
+    processorStats.logical = isInteger(logical) ? parseFloat(logical, 10) : null
+    processorStats.cores = isInteger(cores) ? parseFloat(cores, 10) : null
+    processorStats.packages = isInteger(packages) ? parseFloat(packages, 10) : null
+
+    return processorStats
   } else if (platform.match(/bsd/i)) {
-    getSysctlValue(['hw.ncpu'], function getLogicalCpu(logical) {
-      processorStats.logical = logical
-      callback(processorStats)
-    })
+    const logical = await getSysctlValue(['hw.ncpu'])
+
+    processorStats.logical = logical
+
+    return processorStats
   } else if (platform.match(/linux/i)) {
-    readProc('/proc/cpuinfo', function parseProc(err, data) {
-      callback(parseCpuInfo(data))
-    })
-  } else {
-    logger.debug('Unknown platform: %s; could not retrieve processor info', platform)
-    callback(processorStats)
+    const data = await readProc('/proc/cpuinfo')
+
+    return parseCpuInfo(data)
   }
+
+  logger.debug('Unknown platform: %s; could not retrieve processor info', platform)
+  return processorStats
 }
 
-// placed on module for mocking purposes in tests
-module.exports._getMemoryStats = function getMemoryStats(callback) {
+/**
+ * Helper method for getting detailed, architecture specific RAM information from the system
+ * Exported for testing purposes
+ *
+ * @returns {*} null if unknown platform, otherwise the RAM amount
+ */
+module.exports._getMemoryStats = async function getMemoryStats() {
   if (platform.match(/darwin/i)) {
-    getSysctlValue(['hw.memsize'], function getMem(memory) {
-      callback(parseInt(memory, 10) / (1024 * 1024))
-    })
+    const memory = await getSysctlValue(['hw.memsize'])
+    return parseInt(memory, 10) / (1024 * 1024)
   } else if (platform.match(/bsd/i)) {
-    getSysctlValue(['hw.realmem'], function getMem(memory) {
-      callback(parseInt(memory, 10) / (1024 * 1024))
-    })
+    const memory = await getSysctlValue(['hw.realmem'])
+    return parseInt(memory, 10) / (1024 * 1024)
   } else if (platform.match(/linux/i)) {
-    readProc('/proc/meminfo', function parseProc(err, data) {
-      callback(parseMemInfo(data))
-    })
-  } else {
-    logger.debug('Unknown platform: %s; could not retrieve memory info', platform)
-    callback(null)
+    const data = await readProc('/proc/meminfo')
+    return parseMemInfo(data)
   }
+
+  logger.debug('Unknown platform: %s; could not retrieve memory info', platform)
+  return null
 }
 
-function getKernelVersion(callback) {
+/**
+ * Helper method for retrieving Kernel version information for different platforms
+ *
+ * @returns {*} null if unknown platform, otherwise string representation of kernel version
+ */
+async function getKernelVersion() {
   if (platform.match(/darwin/i) || platform.match(/bsd/i)) {
-    getSysctlValue(['kern.version'], function getMem(version) {
-      callback(version)
-    })
+    return await getSysctlValue(['kern.version'])
   } else if (platform.match(/linux/i)) {
-    readProc('/proc/version', function parseProc(err, data) {
-      callback(data)
-    })
-  } else {
-    logger.debug('Unknown platform: %s; could not read kernel version', platform)
-    callback(null)
+    return await readProc('/proc/version')
   }
+
+  logger.debug('Unknown platform: %s; could not read kernel version', platform)
+  return null
 }
 
-function getSysctlValue(names, callback) {
-  if (!names) {
-    return callback(null)
-  }
-  let returned = false
-  let ran = 0
-  names.forEach(function sysctlName(name) {
-    exec('sysctl -n ' + name, respond)
+/**
+ * Helper method for getting sysctl information given a list of potential values to look up
+ * Returns the first successful sysctl's output
+ *
+ * @param {Array.<string>} names List of sysctl values to look up
+ * @returns {*} null if we failed to lookup any info (error or not), or the first successful sysctl's output
+ */
+async function getSysctlValue(names = []) {
+  let returnValue = null
 
-    function respond(err, stdout, stderr) {
-      if (returned) {
-        return
-      }
-      if (err) {
-        logger.debug('Error when trying to run: sysctl -n %s: %s', name, err.message)
-        callback(null)
-        returned = true
-      } else if (!stderr) {
-        callback(stdout)
-        returned = true
-      }
-      if (++ran === names.length && !returned) {
-        logger.debug('No sysctl info found for names: %j', names)
-        callback(null)
+  for (const name of names) {
+    // returnValue being set means we already found what we were looking for, early exit for performance
+    if (returnValue) {
+      break
+    }
+
+    try {
+      const { stderr, stdout } = await execFile('sysctl', ['-n', name])
+
+      if (!stderr) {
+        returnValue = stdout
       }
+    } catch (err) {
+      logger.debug('Error when trying to run: sysctl -n %s: %s', name, err.message)
     }
-  })
+  }
+
+  if (returnValue === null) {
+    logger.debug('No sysctl info found for names: %j', names)
+  }
+
+  return returnValue
 }

package/lib/util/async-each-limit.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+/**
+ * Helper method for limiting number of concurrent async executions to a certain limit
+ * Native replacement for async.eachLimit, fixes https://issues.newrelic.com/browse/NR-69739
+ *
+ * Shamelessly ripped off from https://github.com/nodejs/help/issues/2192#issuecomment-533730280
+ * and https://timtech.blog/posts/limiting-async-operations-promise-concurrency-javascript/
+ *
+ * @param {Array} items Array to iterate over
+ * @param {Function} fn the callback from Array.map you would normally write that contains an async operation
+ * @param {number} limit the maximum allowed concurrent invocations of `fn`
+ */
+async function eachLimit(items, fn, limit) {
+  const results = []
+
+  while (items.length) {
+    const resolved = await Promise.all(items.splice(0, limit).map(fn))
+    results.push(...resolved)
+  }
+
+  return results
+}
+
+module.exports = eachLimit

package/lib/util/attributes.js

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const NAMES = require('../metrics/names')
+const hashes = require('../util/hashes')
+
+/**
+ * Helper method for modifying attributes by reference if transaction has queue metrics
+ *
+ * @param {object} transaction The current transaction
+ * @param {object} attributes The attributes object to modify (by reference)
+ */
+function maybeAddQueueAttributes(transaction, attributes) {
+  const metric = transaction.metrics.getMetric(NAMES.QUEUETIME)
+
+  if (metric) {
+    attributes.queueDuration = metric.total
+  }
+}
+
+/**
+ * Helper method for modifying attributes by reference if transaction has external call metrics
+ *
+ * @param {object} transaction The current transaction
+ * @param {object} attributes The attributes object to modify (by reference)
+ */
+function maybeAddExternalAttributes(transaction, attributes) {
+  const metric = transaction.metrics.getMetric(NAMES.EXTERNAL.ALL)
+
+  if (metric) {
+    attributes.externalDuration = metric.total
+    attributes.externalCallCount = metric.callCount
+  }
+}
+
+/**
+ * Helper method for modifying attributes by reference if transaction has database metrics
+ *
+ * @param {object} transaction The current transaction
+ * @param {object} attributes The attributes object to modify (by reference)
+ */
+function maybeAddDatabaseAttributes(transaction, attributes) {
+  const metric = transaction.metrics.getMetric(NAMES.DB.ALL)
+
+  if (metric) {
+    attributes.databaseDuration = metric.total
+    attributes.databaseCallCount = metric.callCount
+  }
+}
+
+/**
+ * Helper method for modifying attributes by reference if transaction has DT metrics
+ *
+ * @param {object} transaction The current transaction
+ * @param {object} attributes The attributes object to modify (by reference)
+ */
+function maybeAddParentAttributes(transaction, attributes) {
+  if (transaction.parentSpanId) {
+    attributes.parentSpanId = transaction.parentSpanId
+  }
+
+  if (transaction.parentId) {
+    attributes.parentId = transaction.parentId
+  }
+}
+
+/**
+ * Helper method for modifying attributes by reference if transaction has CAT metrics
+ *
+ * @param {object} transaction The current transaction
+ * @param {object} attributes The attributes object to modify (by reference)
+ * @param {object} configuration Agent configuration options
+ */
+function addRequiredCATAttributes(transaction, attributes, configuration) {
+  attributes['nr.guid'] = transaction.id
+  attributes['nr.tripId'] = transaction.tripId || transaction.id
+  attributes['nr.pathHash'] = hashes.calculatePathHash(
+    configuration.applications()[0],
+    transaction.getFullName(),
+    transaction.referringPathHash
+  )
+}
+
+/**
+ * Helper method for modifying attributes by reference if transaction has additional CAT metrics
+ *
+ * @param {object} transaction The current transaction
+ * @param {object} attributes The attributes object to modify (by reference)
+ * @param {object} configuration Agent configuration options
+ */
+function maybeAddExtraCATAttributes(transaction, attributes, configuration) {
+  if (transaction.referringPathHash) {
+    attributes['nr.referringPathHash'] = transaction.referringPathHash
+  }
+
+  if (transaction.referringTransactionGuid) {
+    const refId = transaction.referringTransactionGuid
+    attributes['nr.referringTransactionGuid'] = refId
+  }
+
+  const alternatePathHashes = transaction.alternatePathHashes()
+  if (alternatePathHashes) {
+    attributes['nr.alternatePathHashes'] = alternatePathHashes
+  }
+
+  if (transaction.baseSegment && transaction.type === 'web') {
+    const apdex =
+      configuration.web_transactions_apdex[transaction.getFullName()] || configuration.apdex_t
+    const duration = transaction.baseSegment.getDurationInMillis() / 1000
+    attributes['nr.apdexPerfZone'] = calculateApdexZone(duration, apdex)
+  }
+}
+
+/**
+ * Helper method for determining a transaction's apdex score based on an apdex threshold and transaction duration
+ *
+ * @param {number} duration number of seconds the transaction took
+ * @param {number} apdexT the apdex threshold
+ * @returns {string} String representation of apdex "zone"
+ */
+function calculateApdexZone(duration, apdexT) {
+  if (duration <= apdexT) {
+    return 'S' // satisfied
+  }
+
+  if (duration <= apdexT * 4) {
+    return 'T' // tolerating
+  }
+
+  return 'F' // frustrated
+}
+
+/**
+ * Helper method for modifying attributes by reference if transaction has Synthetics metrics
+ *
+ * @param {object} transaction The current transaction
+ * @param {object} attributes The attributes object to modify (by reference)
+ */
+function maybeAddSyntheticAttributes(transaction, attributes) {
+  if (transaction.syntheticsData) {
+    attributes['nr.syntheticsResourceId'] = transaction.syntheticsData.resourceId
+    attributes['nr.syntheticsJobId'] = transaction.syntheticsData.jobId
+    attributes['nr.syntheticsMonitorId'] = transaction.syntheticsData.monitorId
+  }
+}
+
+module.exports = {
+  maybeAddQueueAttributes,
+  maybeAddExternalAttributes,
+  maybeAddDatabaseAttributes,
+  maybeAddParentAttributes,
+  addRequiredCATAttributes,
+  maybeAddExtraCATAttributes,
+  maybeAddSyntheticAttributes
+}