newrelic 9.0.0 → 9.0.3

package/lib/collector/api.js

@@ -525,7 +525,7 @@ function transactionSampleData(traces, callback) {
  * @param logRecords
  * @param {Function} callback      The continuation / error handler.
  */
-CollectorAPI.prototype.log_event_data = function errorData(logRecords, callback) {
+CollectorAPI.prototype.log_event_data = function logEventData(logRecords, callback) {
   if (!callback) {
     throw new TypeError('callback is required')
   }

package/lib/collector/facts.js

@@ -5,7 +5,6 @@
 
 'use strict'
 
-const a = require('async')
 const fetchSystemInfo = require('../system-info')
 const logger = require('../logger').child({ component: 'facts' })
 const os = require('os')
@@ -19,94 +18,95 @@ const LOG_LIBRARIES = ['winston', 'bunyan', 'pino', 'loglevel', 'npmlog', 'fancy
 
 module.exports = facts
 
-function facts(agent, callback) {
+async function facts(agent, callback) {
   const startTime = Date.now()
-  a.parallel(
-    {
-      systemInfo: a.apply(fetchSystemInfo, agent),
-      environment: agent.environment.getJSON
-    },
-    function factMapCb(err, data) {
-      logger.trace('Facts gathering finished in %dms', Date.now() - startTime)
 
-      if (err) {
-        logger.debug(err, 'Failed to load system facts!')
-      }
-      data = data || Object.create(null)
-      const systemInfo = data.systemInfo || Object.create(null)
-      const environment = data.environment || []
-
-      countSupportabilityForLogLibraries(environment, agent)
-
-      const hostname = agent.config.getHostnameSafe()
-      const results = {
-        utilization: {
-          metadata_version: 5,
-          logical_processors: systemInfo.logicalProcessors || null,
-          total_ram_mib: systemInfo.memory || null,
-          hostname: hostname
-        },
-        pid: process.pid,
-        host: hostname,
-        display_host: agent.config.getDisplayHost() || hostname,
-        language: 'nodejs',
-        app_name: agent.config.applications(),
-        agent_version: agent.version,
-        environment: environment,
-        settings: agent.config.publicSettings(),
-        high_security: agent.config.high_security,
-        labels: parseLabels(agent.config.labels),
-        metadata: Object.keys(process.env).reduce((obj, key) => {
-          if (key.startsWith('NEW_RELIC_METADATA_')) {
-            obj[key] = process.env[key]
-          }
-          return obj
-        }, {})
-      }
+  const systemInfoPromise = new Promise((resolve) => {
+    fetchSystemInfo(agent, (_, data) => {
+      resolve(data)
+    })
+  })
 
-      logger.debug('New Relic metadata %o', results.metadata)
-
-      /**
-       * WARNING: This may not make sense if you are familiar with our config
-       * and updating of config from server.  But the intention here is to always
-       * send the values from user config of harvest limits because on connect these
-       * values get reconfigured based on harvest cycle intervals.  So if you originally
-       * had 1000 and a harvest of 5 seconds the new value of the harvest limit would be 83.
-       * Then every subsequent connect request it would continue to decrease until it eventually hit 0
-       * and we would never be sampling a certain piece of data.
-       */
-      results.event_harvest_config = {
-        harvest_limits: {
-          analytic_event_data: agent.config.transaction_events.max_samples_stored,
-          custom_event_data: agent.config.custom_insights_events.max_samples_stored,
-          error_event_data: agent.config.error_collector.max_event_samples_stored,
-          span_event_data: agent.config.span_events.max_samples_stored,
-          log_event_data: agent.config.application_logging.forwarding.max_samples_stored
-        }
-      }
+  const environmentPromise = agent.environment.getJSON()
+  let [systemInfo, environment] = await Promise.all([systemInfoPromise, environmentPromise])
+  logger.trace('Facts gathering finished in %dms', Date.now() - startTime)
 
-      results.identifier = getIdentifierOverride(results.app_name)
+  if (environment.failed) {
+    logger.debug(environment.err, 'Failed to load system facts!')
+  }
 
-      const ipAddresses = getAllIPAddresses()
-      if (ipAddresses.length) {
-        results.utilization.ip_address = ipAddresses
-      }
+  systemInfo = systemInfo || Object.create(null)
+  environment = environment || []
 
-      if (systemInfo.bootId) {
-        results.utilization.boot_id = systemInfo.bootId
-      }
+  countSupportabilityForLogLibraries(environment, agent)
 
-      if (systemInfo.vendors) {
-        results.utilization.vendors = systemInfo.vendors
+  const hostname = agent.config.getHostnameSafe()
+  const results = {
+    utilization: {
+      metadata_version: 5,
+      logical_processors: systemInfo.logicalProcessors || null,
+      total_ram_mib: systemInfo.memory || null,
+      hostname: hostname
+    },
+    pid: process.pid,
+    host: hostname,
+    display_host: agent.config.getDisplayHost() || hostname,
+    language: 'nodejs',
+    app_name: agent.config.applications(),
+    agent_version: agent.version,
+    environment: environment,
+    settings: agent.config.publicSettings(),
+    high_security: agent.config.high_security,
+    labels: parseLabels(agent.config.labels),
+    metadata: Object.keys(process.env).reduce((obj, key) => {
+      if (key.startsWith('NEW_RELIC_METADATA_')) {
+        obj[key] = process.env[key]
       }
+      return obj
+    }, {})
+  }
+
+  logger.debug('New Relic metadata %o', results.metadata)
+
+  /**
+   * WARNING: This may not make sense if you are familiar with our config
+   * and updating of config from server.  But the intention here is to always
+   * send the values from user config of harvest limits because on connect these
+   * values get reconfigured based on harvest cycle intervals.  So if you originally
+   * had 1000 and a harvest of 5 seconds the new value of the harvest limit would be 83.
+   * Then every subsequent connect request it would continue to decrease until it eventually hit 0
+   * and we would never be sampling a certain piece of data.
+   */
+  results.event_harvest_config = {
+    harvest_limits: {
+      analytic_event_data: agent.config.transaction_events.max_samples_stored,
+      custom_event_data: agent.config.custom_insights_events.max_samples_stored,
+      error_event_data: agent.config.error_collector.max_event_samples_stored,
+      span_event_data: agent.config.span_events.max_samples_stored,
+      log_event_data: agent.config.application_logging.forwarding.max_samples_stored
+    }
+  }
 
-      if (systemInfo.config) {
-        results.utilization.config = systemInfo.config
-      }
+  results.identifier = getIdentifierOverride(results.app_name)
 
-      return callback(results)
-    }
-  )
+  const ipAddresses = getAllIPAddresses()
+  if (ipAddresses.length) {
+    results.utilization.ip_address = ipAddresses
+  }
+
+  if (systemInfo.bootId) {
+    results.utilization.boot_id = systemInfo.bootId
+  }
+
+  if (systemInfo.vendors) {
+    results.utilization.vendors = systemInfo.vendors
+  }
+
+  if (systemInfo.config) {
+    results.utilization.config = systemInfo.config
+  }
+
+  callback(results)
 }
 
 function getAllIPAddresses() {

package/lib/collector/remote-method.js

@@ -60,7 +60,7 @@ RemoteMethod.prototype.updateEndpoint = function updateEndpoint(endpoint) {
 RemoteMethod.prototype.serialize = function serialize(payload, callback) {
   let res
   try {
-    res = stringify(payload)
+    res = stringify(payload, (key, value) => (typeof value === 'bigint' ? value.toString() : value))
   } catch (error) {
     logger.error(error, 'Unable to serialize payload for method %s.', this.name)
     return process.nextTick(function onNextTick() {
@@ -152,8 +152,8 @@ RemoteMethod.prototype._post = function _post(data, nrHeaders, callback) {
   if (options.compressed) {
     // NOTE: gzip and deflate throw immediately in Node 14+ with an invalid argument
     try {
-      const useGzip = this._config.compressed_content_encoding === 'gzip'
-      const compressor = useGzip ? zlib.gzip : zlib.deflate
+      const useDeflate = this._config.compressed_content_encoding === 'deflate'
+      const compressor = useDeflate ? zlib.deflate : zlib.gzip
       compressor(data, function onCompress(err, compressed) {
         if (err) {
           logger.warn(err, 'Error compressing JSON for delivery. Not sending.')

package/lib/config/default.js

@@ -139,6 +139,16 @@ exports.config = () => ({
    */
   allow_all_headers: false,
 
+  /**
+   * If the data compression threshold is reached in the payload, the
+   * agent compresses data, using gzip compression by default. The
+   * config option `compressed_content_encoding` can be set to 'deflate'
+   * to use deflate compression.
+   *
+   * @env NEW_RELIC_COMPRESSED_CONTENT_ENCODING
+   */
+  compressed_content_encoding: 'gzip',
+
   /**
    * Attributes are key-value pairs containing information that determines
    * the properties of an event or transaction.

package/lib/config/env.js

@@ -22,6 +22,7 @@ const ENV_MAPPING = {
   proxy_pass: 'NEW_RELIC_PROXY_PASS',
   agent_enabled: 'NEW_RELIC_ENABLED',
   allow_all_headers: 'NEW_RELIC_ALLOW_ALL_HEADERS',
+  compressed_content_encoding: 'NEW_RELIC_COMPRESSED_CONTENT_ENCODING',
   attributes: {
     enabled: 'NEW_RELIC_ATTRIBUTES_ENABLED',
     exclude: 'NEW_RELIC_ATTRIBUTES_EXCLUDE',

package/lib/config/index.js

@@ -154,7 +154,6 @@ function Config(config) {
   this.browser_monitoring.loader_version = ''
 
   // Settings to play nice with DLPs (see NODE-1044).
-  this.compressed_content_encoding = 'deflate' // Deflate or gzip
   this.simple_compression = false // Disables subcomponent compression
   this.put_for_data_send = false // Changes http verb for harvest
 

package/lib/db/query-trace-aggregator.js

@@ -5,7 +5,6 @@
 
 'use strict'
 
-const a = require('async')
 const logger = require('../logger').child({ component: 'query_tracer' })
 const Aggregator = require('../aggregators/base-aggregator')
 const SlowQuery = require('./slow-query')
@@ -132,8 +131,26 @@ class QueryTraceAggregator extends Aggregator {
     this.samples = new Map()
   }
 
-  prepareJSON(done) {
-    a.map(this.samples.values(), (sample, cb) => sample.prepareJSON(cb), done)
+  async prepareJSON(done) {
+    const samplePromises = []
+    for (const sample of this.samples.values()) {
+      const samplePromise = new Promise((resolve, reject) => {
+        sample.prepareJSON((err, data) => {
+          if (err) {
+            reject(err)
+          }
+          resolve(data)
+        })
+      })
+      samplePromises.push(samplePromise)
+    }
+
+    try {
+      const data = await Promise.all(samplePromises)
+      done(null, data)
+    } catch (err) {
+      done(err)
+    }
   }
 
   prepareJSONSync() {