newrelic 7.5.2 → 8.3.0

package/lib/attributes.js

@@ -6,7 +6,7 @@
 'use strict'
 
 const Config = require('./config')
-const logger = require('./logger').child({component: 'attributes'})
+const logger = require('./logger').child({ component: 'attributes' })
 const isValidType = require('./util/attribute-types')
 const byteUtils = require('./util/byte-limit')
 const properties = require('./util/properties')
@@ -52,7 +52,7 @@ class Attributes {
    * @param {boolean} truncateExempt - Flag marking value exempt from truncation
    */
   _set(destinations, key, value, truncateExempt) {
-    this.attributes[key] = {value, destinations, truncateExempt}
+    this.attributes[key] = { value, destinations, truncateExempt }
   }
 
   /**
@@ -65,15 +65,17 @@ class Attributes {
    */
   get(dest) {
     const attrs = Object.create(null)
-    for (let key in this.attributes) { // eslint-disable-line guard-for-in
+    // eslint-disable-next-line guard-for-in
+    for (let key in this.attributes) {
       const attr = this.attributes[key]
       if (!(attr.destinations & dest)) {
         continue
       }
 
-      attrs[key] = typeof attr.value === 'string' && !attr.truncateExempt
-        ? byteUtils.truncate(attr.value, 255)
-        : attr.value
+      attrs[key] =
+        typeof attr.value === 'string' && !attr.truncateExempt
+          ? byteUtils.truncate(attr.value, 255)
+          : attr.value
     }
 
     return attrs
@@ -116,18 +118,15 @@ class Attributes {
     if (!isValidType(value)) {
       return logger.debug(
         'Not adding attribute %s with %s value type. This is expected for undefined' +
-        'attributes and only an issue if an attribute is not expected to be undefined' +
-        'or not of the type expected.',
+          'attributes and only an issue if an attribute is not expected to be undefined' +
+          'or not of the type expected.',
         key,
         typeof value
       )
     }
 
     if (!this.isValidLength(key)) {
-      return logger.warn(
-        'Length limit exceeded for attribute name, not adding: %s',
-        key
-      )
+      return logger.warn('Length limit exceeded for attribute name, not adding: %s', key)
     }
 
     // Only set the attribute if at least one destination passed
@@ -174,7 +173,7 @@ class Attributes {
  *  scope.
  */
 function makeFilter(scope) {
-  const {attributeFilter} = Config.getInstance()
+  const { attributeFilter } = Config.getInstance()
   if (scope === 'transaction') {
     return (d, k) => attributeFilter.filterTransaction(d, k)
   } else if (scope === 'segment') {

package/lib/collector/api.js

@@ -7,7 +7,7 @@
 
 const CollectorResponse = require('./response')
 const facts = require('./facts')
-const logger = require('../logger').child({component: 'collector_api'})
+const logger = require('../logger').child({ component: 'collector_api' })
 const RemoteMethod = require('./remote-method')
 
 const NAMES = require('../metrics/names')
@@ -19,21 +19,19 @@ const TO_MILLIS = 1e3
 
 // taken directly from Python agent's newrelic.core.application
 const BACKOFFS = [
-  {interval: 15, warn: false},
-  {interval: 15, warn: false},
-  {interval: 30, warn: false},
-  {interval: 60, warn: true},
-  {interval: 120, warn: false},
-  {interval: 300, warn: false}
+  { interval: 15, warn: false },
+  { interval: 15, warn: false },
+  { interval: 30, warn: false },
+  { interval: 60, warn: true },
+  { interval: 120, warn: false },
+  { interval: 300, warn: false }
 ]
 
 // Expected collector response codes
 const SUCCESS = new Set([200, 202])
 const RESTART = new Set([401, 409])
 const FAILURE_SAVE_DATA = new Set([408, 429, 500, 503])
-const FAILURE_DISCARD_DATA = new Set(
-  [400, 403, 404, 405, 407, 411, 413, 414, 415, 417, 431]
-)
+const FAILURE_DISCARD_DATA = new Set([400, 403, 404, 405, 407, 411, 413, 414, 415, 417, 431])
 
 const AGENT_RUN_BEHAVIOR = CollectorResponse.AGENT_RUN_BEHAVIOR
 
@@ -51,7 +49,6 @@ function dumpErrors(errors, name) {
   })
 }
 
-
 function CollectorAPI(agent) {
   this._agent = agent
   this._reqHeadersMap = null
@@ -128,9 +125,13 @@ CollectorAPI.prototype.connect = function connect(callback) {
    */
   function isProxyMisconfigured(error) {
     const config = api._agent.config
-    return error &&
+    return (
+      error &&
       ['EPROTO', 'ECONNRESET'].includes(error.code) &&
-      config.proxy_host && config.proxy_port && !config.proxy
+      config.proxy_host &&
+      config.proxy_port &&
+      !config.proxy
+    )
   }
 
   function retry(error, response) {
@@ -154,26 +155,23 @@ CollectorAPI.prototype.connect = function connect(callback) {
       logger.warn(
         error,
         'Your license key appears to be invalid. Reattempting connection to New' +
-        ' Relic. If the problem persists, please contact support@newrelic.com.' +
-        ' (status code %s)',
+          ' Relic. If the problem persists, please contact support@newrelic.com.' +
+          ' (status code %s)',
         response.status
       )
     } else if (isProxyMisconfigured(error)) {
       logger.warn(
         error,
         'Your proxy server appears to be configured to accept connections over http. ' +
-        'When setting `proxy_host` and `proxy_port` New Relic attempts to connect over ' +
-        'SSL(https). If your proxy is configured to accept connections over http, try ' +
-        'setting `proxy` to a fully qualified URL(e.g http://proxy-host:8080).'
+          'When setting `proxy_host` and `proxy_port` New Relic attempts to connect over ' +
+          'SSL(https). If your proxy is configured to accept connections over http, try ' +
+          'setting `proxy` to a fully qualified URL(e.g http://proxy-host:8080).'
       )
     }
 
     let backoff = BACKOFFS[Math.min(attempts, max) - 1]
     if (backoff.warn) {
-      logger.warn(
-        'No connection has been established to New Relic after %d attempts.',
-        attempts
-      )
+      logger.warn('No connection has been established to New Relic after %d attempts.', attempts)
     }
 
     logger.debug(
@@ -327,9 +325,13 @@ CollectorAPI.prototype.reportSettings = function reportSettings(callback) {
     [this._agent.config.publicSettings()],
     this._reqHeadersMap,
     function onReportSettings(error, response) {
-      if (error) dumpErrors([error], 'agent_settings')
+      if (error) {
+        dumpErrors([error], 'agent_settings')
+      }
 
-      if (callback) callback(error, response)
+      if (callback) {
+        callback(error, response)
+      }
     }
   )
 }
@@ -498,10 +500,7 @@ CollectorAPI.prototype.shutdown = function shutdown(callback) {
     }
 
     agent.setState('disconnected')
-    logger.info(
-      'Disconnected from New Relic; clearing run ID %s.',
-      agent.config.run_id
-    )
+    logger.info('Disconnected from New Relic; clearing run ID %s.', agent.config.run_id)
     agent.config.run_id = undefined
 
     callback(error, CollectorResponse.fatal(response && response.payload))
@@ -515,9 +514,8 @@ CollectorAPI.prototype.restart = function restart(callback) {
   var api = this
   this.shutdown(function reconnect() {
     api.connect(function afterConnect() {
-      api._agent.onConnect()
-      api._agent.startAggregators()
-      return callback.apply(null, arguments)
+      const shouldImmediatelyHarvest = false
+      api._agent.onConnect(shouldImmediatelyHarvest, callback)
     })
   })
 }
@@ -573,7 +571,7 @@ CollectorAPI.prototype._sendData = function _sendData(method, data, callback) {
       //   // but don't really care about that *here*
       // })
 
-      callback(null, {retainData: response.retainData})
+      callback(null, { retainData: response.retainData })
     } else if (response.agentRun === AGENT_RUN_BEHAVIOR.RESTART) {
       // TODO: almost seems better to leg aggregator finish (cb) then restart?
 
@@ -590,7 +588,7 @@ CollectorAPI.prototype._sendData = function _sendData(method, data, callback) {
           logger.trace('Restart succeeded.')
         }
 
-        callback(null, {retainData: response.retainData})
+        callback(null, { retainData: response.retainData })
         // TODO: keep object or enum of actions? retain / split / other?
       })
     } else {
@@ -601,7 +599,6 @@ CollectorAPI.prototype._sendData = function _sendData(method, data, callback) {
   })
 }
 
-
 CollectorAPI.prototype.isConnected = function isConnected() {
   return !!this._agent.config.run_id
 }
@@ -627,17 +624,14 @@ function _handleResponseCode(response, endpoint, cb) {
     // The agent needs to disconnect and restart.
     logFailure(endpoint, code, 'Restarting')
     return setImmediate(cb, null, CollectorResponse.reconnect(0, null))
-
   } else if (FAILURE_DISCARD_DATA.has(code)) {
     // Something was wrong with our payload so we must delete our data.
     logFailure(endpoint, code, 'Discarding harvest data')
     return setImmediate(cb, null, CollectorResponse.discard(null))
-
   } else if (FAILURE_SAVE_DATA.has(code)) {
     // Something was wrong with the request, but it wasn't our fault. We'll try again.
     logFailure(endpoint, code, 'Retaining data for next harvest')
     return setImmediate(cb, null, CollectorResponse.error(response.payload))
-
   } else if (code === 410) {
     // New Relic doesn't like us and we shouldn't try to talk to them any more.
     logFailure(endpoint, code, 'Disconnecting from New Relic')
@@ -650,11 +644,7 @@ function _handleResponseCode(response, endpoint, cb) {
 
   // We're not sure what New Relic is trying to tell us. Let's get rid of our
   // data just in case it is our fault.
-  logger.error(
-    'Agent endpoint %s returned unexpected status %s.',
-    endpoint,
-    code
-  )
+  logger.error('Agent endpoint %s returned unexpected status %s.', endpoint, code)
   return setImmediate(cb, null, CollectorResponse.discard(null))
 }
 

package/lib/collector/facts.js

@@ -7,86 +7,88 @@
 
 const a = require('async')
 const fetchSystemInfo = require('../system-info')
-const logger = require('../logger').child({component: 'facts'})
+const logger = require('../logger').child({ component: 'facts' })
 const os = require('os')
-const parse_labels = require('../util/label-parser')
-const Config = require('../config/')
+const parseLabels = require('../util/label-parser')
 
 module.exports = facts
 
 function facts(agent, callback) {
   var 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 || []
-
-    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: parse_labels(agent.config.labels),
-      metadata: Object.keys(process.env).reduce((obj, key) => {
-        if (key.startsWith('NEW_RELIC_METADATA_')) {
-          obj[key] = process.env[key]
-        }
-        return obj
-      }, {})
-    }
+  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 || []
+
+      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)
+      logger.debug('New Relic metadata %o', results.metadata)
 
-    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: Config.SPAN_EVENT_LIMIT
+      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
+        }
       }
-    }
 
-    results.identifier = getIdentifierOverride(results.app_name)
+      results.identifier = getIdentifierOverride(results.app_name)
 
-    const ipAddresses = getAllIPAddresses()
-    if (ipAddresses.length) {
-      results.utilization.ip_address = ipAddresses
-    }
+      const ipAddresses = getAllIPAddresses()
+      if (ipAddresses.length) {
+        results.utilization.ip_address = ipAddresses
+      }
 
-    if (systemInfo.bootId) {
-      results.utilization.boot_id = systemInfo.bootId
-    }
+      if (systemInfo.bootId) {
+        results.utilization.boot_id = systemInfo.bootId
+      }
 
-    if (systemInfo.vendors) {
-      results.utilization.vendors = systemInfo.vendors
-    }
+      if (systemInfo.vendors) {
+        results.utilization.vendors = systemInfo.vendors
+      }
 
-    if (systemInfo.config) {
-      results.utilization.config = systemInfo.config
-    }
+      if (systemInfo.config) {
+        results.utilization.config = systemInfo.config
+      }
 
-    return callback(results)
-  })
+      return callback(results)
+    }
+  )
 }
 
 function getAllIPAddresses() {

package/lib/collector/http-agents.js

@@ -7,7 +7,7 @@
 
 var parse = require('url').parse
 var ProxyAgent = require('https-proxy-agent')
-var logger = require('../logger').child({component: 'http-agent'})
+var logger = require('../logger').child({ component: 'http-agent' })
 var certificates = require('./ssl/certificates.js')
 
 const https = require('https')
@@ -51,56 +51,59 @@ exports.proxyAgent = function proxyAgent(config) {
     return agentProxyWithKeepAlive
   }
   var opts = proxyOptions(config)
-  var proxy_url = opts.proxy_url
+  var proxyUrl = opts.proxy_url
 
-  var proxy_opts = {
-    host: proxy_url.host,
-    port: proxy_url.port,
-    protocol: proxy_url.protocol,
+  var proxyOpts = {
+    host: proxyUrl.host,
+    port: proxyUrl.port,
+    protocol: proxyUrl.protocol,
     secureEndpoint: config.ssl,
-    auth: proxy_url.auth,
+    auth: proxyUrl.auth,
     ca: opts.certificates,
     keepAlive: true
   }
 
-  logger.info({
-    host: proxy_opts.host,
-    port: proxy_opts.port,
-    auth: !!proxy_opts.auth,
-    protocol: proxy_url.protocol
-  }, 'using proxy')
-
-  agentProxyWithKeepAlive = new ProxyAgent(proxy_opts)
+  logger.info(
+    {
+      host: proxyOpts.host,
+      port: proxyOpts.port,
+      auth: !!proxyOpts.auth,
+      protocol: proxyUrl.protocol
+    },
+    'using proxy'
+  )
+
+  agentProxyWithKeepAlive = new ProxyAgent(proxyOpts)
   return agentProxyWithKeepAlive
 }
 
 function proxyOptions(config) {
   if (config.proxy) {
-    var parsed_url = parse(config.proxy)
+    var parsedUrl = parse(config.proxy)
 
-    var proxy_url = {
-      protocol: parsed_url.protocol || 'https:',
-      host: parsed_url.hostname,
-      port: parsed_url.port || 80,
-      auth: parsed_url.auth
+    var proxyUrl = {
+      protocol: parsedUrl.protocol || 'https:',
+      host: parsedUrl.hostname,
+      port: parsedUrl.port || 80,
+      auth: parsedUrl.auth
     }
   } else {
-    var proxy_auth = config.proxy_user
+    var proxyAuth = config.proxy_user
     if (config.proxy_pass !== '') {
-      proxy_auth += ':' + config.proxy_pass
+      proxyAuth += ':' + config.proxy_pass
     }
 
     // Unless a proxy config is provided, default to HTTP.
-    proxy_url = {
+    proxyUrl = {
       protocol: 'https:',
       host: config.proxy_host || 'localhost',
       port: config.proxy_port || 80,
-      auth: proxy_auth
+      auth: proxyAuth
     }
   }
 
   var opts = {
-    proxy_url: proxy_url
+    proxy_url: proxyUrl
   }
 
   if (config.certificates && config.certificates.length > 0) {
@@ -110,7 +113,7 @@ function proxyOptions(config) {
     if (config.feature_flag.certificate_bundle) {
       logger.info(
         'Using a proxy with a special cert. This enables our cert bundle which, combined ' +
-        'with some versions of node, exacerbates a leak in node core TLS.'
+          'with some versions of node, exacerbates a leak in node core TLS.'
       )
 
       const certWarningMessage = [

package/lib/collector/parse-response.js

@@ -5,8 +5,7 @@
 
 'use strict'
 
-const logger = require('../logger').child({component: 'new_relic_response'})
-
+const logger = require('../logger').child({ component: 'new_relic_response' })
 
 /**
  * The collector has many ways of indicating failure, and isn't

package/lib/collector/remote-method.js

@@ -9,7 +9,7 @@ var util = require('util')
 var url = require('url')
 var https = require('https')
 var zlib = require('zlib')
-var logger = require('../logger').child({component: 'remote_method'})
+var logger = require('../logger').child({ component: 'remote_method' })
 var parse = require('./parse-response')
 var stringify = require('json-stringify-safe')
 var Sink = require('../util/stream-sink')
@@ -76,13 +76,20 @@ RemoteMethod.prototype.invoke = function invoke(payload, nrHeaders, callback) {
     nrHeaders = null
   }
 
-  if (!payload) payload = []
+  if (!payload) {
+    payload = []
+  }
   logger.trace('Invoking remote method %s', this.name)
 
-  this.serialize(payload, function onSerialize(err, serialized) {
-    if (err) return callback(err)
-    this._post(serialized, nrHeaders, callback)
-  }.bind(this))
+  this.serialize(
+    payload,
+    function onSerialize(err, serialized) {
+      if (err) {
+        return callback(err)
+      }
+      this._post(serialized, nrHeaders, callback)
+    }.bind(this)
+  )
 }
 
 /**
@@ -108,11 +115,7 @@ RemoteMethod.prototype._post = function _post(data, nrHeaders, callback) {
 
   // Check trace enabled first since we're creating an object for this log message.
   if (logger.traceEnabled()) {
-    logger.trace(
-      {data, compressed: options.compressed},
-      'Calling %s on collector API',
-      this.name
-    )
+    logger.trace({ data, compressed: options.compressed }, 'Calling %s on collector API', this.name)
   }
 
   if (options.compressed) {
@@ -150,10 +153,7 @@ RemoteMethod.prototype._post = function _post(data, nrHeaders, callback) {
   // set up standard response handling
   function onResponse(response) {
     response.on('end', function onEnd() {
-      logger.debug(
-        'Finished receiving data back from the collector for %s.',
-        method.name
-      )
+      logger.debug('Finished receiving data back from the collector for %s.', method.name)
     })
 
     response.setEncoding('utf8')
@@ -175,13 +175,27 @@ RemoteMethod.prototype._post = function _post(data, nrHeaders, callback) {
  * @param {object} options A dictionary of request parameters.
  */
 RemoteMethod.prototype._safeRequest = function _safeRequest(options) {
-  if (!options) throw new Error('Must include options to make request!')
-  if (!options.host) throw new Error('Must include collector hostname!')
-  if (!options.port) throw new Error('Must include collector port!')
-  if (!options.onError) throw new Error('Must include error handler!')
-  if (!options.onResponse) throw new Error('Must include response handler!')
-  if (!options.body) throw new Error('Must include body to send to collector!')
-  if (!options.path) throw new Error('Must include URL to request!')
+  if (!options) {
+    throw new Error('Must include options to make request!')
+  }
+  if (!options.host) {
+    throw new Error('Must include collector hostname!')
+  }
+  if (!options.port) {
+    throw new Error('Must include collector port!')
+  }
+  if (!options.onError) {
+    throw new Error('Must include error handler!')
+  }
+  if (!options.onResponse) {
+    throw new Error('Must include response handler!')
+  }
+  if (!options.body) {
+    throw new Error('Must include body to send to collector!')
+  }
+  if (!options.path) {
+    throw new Error('Must include URL to request!')
+  }
 
   var protocol = 'https'
   var logConfig = this._config.logging
@@ -209,10 +223,9 @@ RemoteMethod.prototype._safeRequest = function _safeRequest(options) {
     }
   }
 
-  const logBody =
-    Buffer.isBuffer(options.body) ? 'Buffer ' + options.body.length : options.body
+  const logBody = Buffer.isBuffer(options.body) ? 'Buffer ' + options.body.length : options.body
   logger[level](
-    {body: logBody},
+    { body: logBody },
     'Posting to %s://%s:%s%s',
     protocol,
     options.host,
@@ -241,21 +254,17 @@ RemoteMethod.prototype._safeRequest = function _safeRequest(options) {
 RemoteMethod.prototype._request = function _request(options) {
   var requestOptions = {
     method: this._config.put_for_data_send ? 'PUT' : 'POST',
-    setHost: false,         // See below
-    host: options.host,     // Set explicitly in the headers
+    setHost: false, // See below
+    host: options.host, // Set explicitly in the headers
     port: options.port,
     path: options.path,
     headers: this._headers(options),
     agent: agents.keepAliveAgent(),
-    __NR__connection: true,  // Who measures the metrics measurer?
+    __NR__connection: true // Who measures the metrics measurer?
   }
   var request
 
-  var isProxy = !!(
-    this._config.proxy ||
-    this._config.proxy_port ||
-    this._config.proxy_host
-  )
+  var isProxy = !!(this._config.proxy || this._config.proxy_port || this._config.proxy_host)
 
   if (isProxy) {
     // proxy
@@ -266,9 +275,7 @@ RemoteMethod.prototype._request = function _request(options) {
       requestOptions.ca = this._config.certificates
 
       if (this._config.feature_flag.certificate_bundle) {
-        logger.debug(
-          'Adding custom certificate to the cert bundle.'
-        )
+        logger.debug('Adding custom certificate to the cert bundle.')
 
         const certWarningMessage = [
           'Deprecation Warning: The certificate bundle included by New Relic will be ',