newrelic 5.13.0 → 6.2.0

package/lib/agent.js

@@ -9,7 +9,6 @@ const ErrorCollector = require('./errors/error-collector')
 const ErrorTraceAggregator = require('./errors/error-trace-aggregator')
 const ErrorEventAggregator = require('./errors/error-event-aggregator')
 const EventEmitter = require('events').EventEmitter
-const Harvest = require('./harvest')
 const hashes = require('./util/hashes')
 const logger = require('./logger')
 const MetricMapper = require('./metrics/mapper')
@@ -26,8 +25,6 @@ const TxSegmentNormalizer = require('./metrics/normalizer/tx_segment')
 const uninstrumented = require('./uninstrumented')
 const util = require('util')
 
-const AGENT_RUN_BEHAVIOR = require('./collector/response').AGENT_RUN_BEHAVIOR
-
 // Map of valid states to whether or not data collection is valid
 const STATES = {
   stopped: false,
@@ -40,9 +37,6 @@ const STATES = {
   errored: false
 }
 
-// just to make clear what's going on
-const TO_MILLIS = 1e3
-
 const MAX_ERROR_TRACES_DEFAULT = 20
 const INITIAL_HARVEST_DELAY_MS = 1000
 const DEFAULT_HARVEST_INTERVAL_MS = 60000
@@ -67,8 +61,6 @@ function Agent(config) {
   this.version = this.config.version
 
   if (config.serverless_mode.enabled) {
-    // TODO: once all harvesting is done through aggregators,
-    // change the ServerlessCollector to no longer rely on the harvest class.
     this.collector = new ServerlessCollector(this)
   } else {
     this.collector = new CollectorAPI(this)
@@ -87,6 +79,11 @@ function Agent(config) {
     this.collector
   )
 
+  this.metrics.on(
+    'starting metric_data data send.',
+    this._beforeMetricDataSend.bind(this)
+  )
+
   // Open tracing.
   this.spanEventAggregator = new SpanEventAggregator({
     periodMs: config.event_harvest_config.report_period_ms,
@@ -150,7 +147,7 @@ function Agent(config) {
   this.tracer = new Tracer(this)
   this.traces = new TransactionTraceAggregator(
     {
-      periodMs: config.event_harvest_config.report_period_ms,
+      periodMs: DEFAULT_HARVEST_INTERVAL_MS,
       config: this.config,
       isAsync: !config.serverless_mode.enabled,
       method: 'transaction_sample_data'
@@ -167,7 +164,7 @@ function Agent(config) {
   this.queries = new QueryTraceAggregator(
     {
       config: this.config,
-      periodMs: config.event_harvest_config.report_period_ms,
+      periodMs: DEFAULT_HARVEST_INTERVAL_MS,
       method: 'sql_trace_data',
       isAsync: !config.serverless_mode.enabled
     },
@@ -181,12 +178,8 @@ function Agent(config) {
   this.totalActiveSegments = 0
   this.segmentsCreatedInHarvest = 0
   this.segmentsClearedInHarvest = 0
+  // Used by shutdown code as well as entity tracking stats
   this.activeTransactions = 0
-  this.transactionsCreatedInHarvest = 0
-
-  // Harvest attributes.
-  this.harvesterHandle = null
-  this._lastHarvest = null
 
   // Finally, add listeners for the agent's own events.
   this.on('transactionFinished', this._transactionFinished.bind(this))
@@ -264,124 +257,7 @@ Agent.prototype.start = function start(callback) {
         setTimeout(function afterTimeout() {
           logger.info(`Starting initial ${INITIAL_HARVEST_DELAY_MS}ms harvest.`)
 
-          const promises = []
-
-          const metricPromise = new Promise((resolve) => {
-            agent.metrics.once(
-              'finished metric_data data send.',
-              function onMetricsFinished() {
-                resolve()
-              }
-            )
-            agent.metrics.send()
-          })
-
-          promises.push(metricPromise)
-
-          // TODO: plumb config through to aggregators so they can do their own checking.
-          if (agent.config.distributed_tracing.enabled &&
-              agent.config.span_events.enabled) {
-            const spanPromise = new Promise((resolve) => {
-              agent.spanEventAggregator.once(
-                'finished span_event_data data send.',
-                function onSpansFinished() {
-                  resolve()
-                }
-              )
-              agent.spanEventAggregator.send()
-            })
-
-            promises.push(spanPromise)
-          }
-
-          if (agent.config.custom_insights_events.enabled) {
-            const customEventPromise = new Promise((resolve) => {
-              agent.customEventAggregator.once(
-                'finished custom_event_data data send.',
-                function onCustomEventsFinished() {
-                  resolve()
-                }
-              )
-              agent.customEventAggregator.send()
-            })
-
-            promises.push(customEventPromise)
-          }
-
-          if (agent.config.transaction_events.enabled) {
-            const transactionEventPromise = new Promise((resolve) => {
-              agent.transactionEventAggregator.once(
-                'finished analytic_event_data data send.',
-                function onTransactionEventsFinished() {
-                  resolve()
-                }
-              )
-              agent.transactionEventAggregator.send()
-            })
-
-            promises.push(transactionEventPromise)
-          }
-
-          if (agent.config.transaction_tracer.enabled && agent.config.collect_traces) {
-            const transactionTracePromise = new Promise((resolve) => {
-              agent.traces.once(
-                'finished transaction_sample_data data send.',
-                function onTracesFinished() {
-                  resolve()
-                }
-              )
-              agent.traces.send()
-            })
-
-            promises.push(transactionTracePromise)
-          }
-
-          if (agent.config.slow_sql.enabled) {
-            const sqlTracePromise = new Promise((resolve) => {
-              agent.queries.once(
-                'finished sql_trace_data data send.',
-                function onSqlTracesFinished() {
-                  resolve()
-                }
-              )
-              agent.queries.send()
-            })
-
-            promises.push(sqlTracePromise)
-          }
-
-          const errorCollectorEnabled =
-            agent.config.error_collector && agent.config.error_collector.enabled
-
-          if (errorCollectorEnabled && agent.config.collect_errors) {
-            const errorTracePromise = new Promise((resolve) => {
-              agent.errors.traceAggregator.once(
-                'finished error_data data send.',
-                function onErrorTracesFinished() {
-                  resolve()
-                }
-              )
-              agent.errors.traceAggregator.send()
-            })
-
-            promises.push(errorTracePromise)
-          }
-
-          if (errorCollectorEnabled && agent.config.error_collector.capture_events) {
-            const errorEventPromise = new Promise((resolve) => {
-              agent.errors.eventAggregator.once(
-                'finished error_event_data data send.',
-                function onErrorEventsFinished() {
-                  resolve()
-                }
-              )
-              agent.errors.eventAggregator.send()
-            })
-
-            promises.push(errorEventPromise)
-          }
-
-          Promise.all(promises).then(function afterAllAggregatorsSend() {
+          agent.forceHarvestAll(function afterAllAggregatorsSend() {
             agent.startAggregators()
             callback(null, config)
           })
@@ -393,6 +269,136 @@ Agent.prototype.start = function start(callback) {
   })
 }
 
+/**
+ * Forces all aggregators to send the data collected.
+ * @param {Function} callback The callback to invoke when all data types have been sent.
+ */
+Agent.prototype.forceHarvestAll = function forceHarvestAll(callback) {
+  const agent = this
+  const promises = []
+
+  const metricPromise = new Promise((resolve) => {
+    agent.metrics.once(
+      'finished metric_data data send.',
+      function onMetricsFinished() {
+        resolve()
+      }
+    )
+    agent.metrics.send()
+  })
+
+  promises.push(metricPromise)
+
+  // TODO: plumb config through to aggregators so they can do their own checking.
+  if (agent.config.distributed_tracing.enabled &&
+      agent.config.span_events.enabled) {
+    const spanPromise = new Promise((resolve) => {
+      agent.spanEventAggregator.once(
+        'finished span_event_data data send.',
+        function onSpansFinished() {
+          resolve()
+        }
+      )
+      agent.spanEventAggregator.send()
+    })
+
+    promises.push(spanPromise)
+  }
+
+  if (agent.config.custom_insights_events.enabled) {
+    const customEventPromise = new Promise((resolve) => {
+      agent.customEventAggregator.once(
+        'finished custom_event_data data send.',
+        function onCustomEventsFinished() {
+          resolve()
+        }
+      )
+      agent.customEventAggregator.send()
+    })
+
+    promises.push(customEventPromise)
+  }
+
+  if (agent.config.transaction_events.enabled) {
+    const transactionEventPromise = new Promise((resolve) => {
+      agent.transactionEventAggregator.once(
+        'finished analytic_event_data data send.',
+        function onTransactionEventsFinished() {
+          resolve()
+        }
+      )
+      agent.transactionEventAggregator.send()
+    })
+
+    promises.push(transactionEventPromise)
+  }
+
+  if (agent.config.transaction_tracer.enabled && agent.config.collect_traces) {
+    const transactionTracePromise = new Promise((resolve) => {
+      agent.traces.once(
+        'finished transaction_sample_data data send.',
+        function onTracesFinished() {
+          resolve()
+        }
+      )
+      agent.traces.send()
+    })
+
+    promises.push(transactionTracePromise)
+  }
+
+  if (agent.config.slow_sql.enabled) {
+    const sqlTracePromise = new Promise((resolve) => {
+      agent.queries.once(
+        'finished sql_trace_data data send.',
+        function onSqlTracesFinished() {
+          resolve()
+        }
+      )
+      agent.queries.send()
+    })
+
+    promises.push(sqlTracePromise)
+  }
+
+  const errorCollectorEnabled =
+    agent.config.error_collector && agent.config.error_collector.enabled
+
+  if (errorCollectorEnabled && agent.config.collect_errors) {
+    const errorTracePromise = new Promise((resolve) => {
+      agent.errors.traceAggregator.once(
+        'finished error_data data send.',
+        function onErrorTracesFinished() {
+          resolve()
+        }
+      )
+      agent.errors.traceAggregator.send()
+    })
+
+    promises.push(errorTracePromise)
+  }
+
+  if (errorCollectorEnabled && agent.config.error_collector.capture_events) {
+    const errorEventPromise = new Promise((resolve) => {
+      agent.errors.eventAggregator.once(
+        'finished error_event_data data send.',
+        function onErrorEventsFinished() {
+          resolve()
+        }
+      )
+      agent.errors.eventAggregator.send()
+    })
+
+    promises.push(errorEventPromise)
+  }
+
+  Promise.all(promises).then(() => {
+    // Get out of the promise so callback errors aren't treated as
+    // promise rejections.
+    setImmediate(callback)
+  })
+}
+
 Agent.prototype.stopAggregators = function stopAggregators() {
   this.metrics.stop()
   this.errors.stop()
@@ -468,7 +474,6 @@ Agent.prototype.stop = function stop(callback) {
 
   this.stopAggregators()
 
-  this._stopHarvester()
   sampler.stop()
 
   if (this.collector.isConnected()) {
@@ -522,82 +527,6 @@ Agent.prototype._resetCustomEvents = function resetCustomEvents() {
   this.customEventAggregator.clear()
 }
 
-/**
- * On agent startup, an interval timer is started that calls this method once
- * a minute, which in turn invokes the pieces of the harvest cycle. It calls
- * the various collector API methods in order, bailing out if one of them fails,
- * to ensure that the agents don't pummel the collector if it's already
- * struggling.
- */
-Agent.prototype.harvest = function harvest(callback) {
-  logger.trace('Peparing to harvest.')
-
-  if (!callback) {
-    throw new TypeError('callback required!')
-  }
-
-  // Generate metrics for this harvest and then check we are connected to the
-  // collector.
-  this._generateHarvestMetrics()
-
-  if (!this.collector.isConnected()) {
-    logger.trace('Collector not connected.')
-
-    return setImmediate(function immediatelyError() {
-      callback(new Error('Not connected to New Relic!'))
-    })
-  }
-
-  // We have a connection, create a new harvest.
-  this.emit('harvestStarted')
-  logger.info('Harvest started.')
-
-  this._lastHarvest = new Harvest(this)
-  this._lastHarvest.prepare(Harvest.ALL_ENDPOINTS)
-
-  // Send the harvest!
-  const collector = this.collector
-  const agent = this
-
-  logger.trace('Sending harvest data...')
-  this._lastHarvest.send(function afterHarvest(err, agentRunAction) {
-    // Do we need to do anything to the agent run?
-    if (agentRunAction === AGENT_RUN_BEHAVIOR.SHUTDOWN) {
-      agent.emit('harvestFinished')
-      logger.info('Harvest finished. Shutdown requested.')
-
-      agent.stop(function afterStop(stopError) {
-        const shutdownError = stopError || err
-        callback(shutdownError)
-      })
-    } else if (agentRunAction === AGENT_RUN_BEHAVIOR.RESTART) {
-      logger.info('Restart requested. Harvest will complete upon restart finish.')
-
-      collector.restart(function afterRestart(restartError) {
-        // TODO: What if preconnect/connect respond with shutdown here?
-        if (restartError) {
-          logger.warn('Failed to restart agent run after harvest')
-          callback(restartError)
-        } else {
-          logger.trace('Restart succeeded. Finishing harvest.')
-          _finish(err)
-        }
-      })
-    } else {
-      logger.trace('Data sent successfully. Finishing harvest.')
-      _finish(err)
-    }
-
-    function _finish(error) {
-      agent.emit('harvestFinished')
-      logger.info('Harvest finished.')
-
-      agent._scheduleHarvester(agent.config.data_report_period)
-      callback(error)
-    }
-  })
-}
-
 /**
  * This method invokes a harvest synchronously.
  *
@@ -606,10 +535,6 @@ Agent.prototype.harvest = function harvest(callback) {
 Agent.prototype.harvestSync = function harvestSync() {
   logger.trace('Peparing to harvest.')
 
-  // Generate metrics for this harvest and then check we are connected to the
-  // collector.
-  this._generateHarvestMetrics()
-
   if (!this.collector.isConnected()) {
     throw new Error('Sync harvest not connected/enabled!')
   }
@@ -618,9 +543,6 @@ Agent.prototype.harvestSync = function harvestSync() {
   this.emit('harvestStarted')
   logger.info('Harvest started.')
 
-  this._lastHarvest = new Harvest(this)
-  this._lastHarvest.prepare(Harvest.ALL_ENDPOINTS)
-
   const collector = this.collector
   const agent = this
 
@@ -641,7 +563,14 @@ Agent.prototype.harvestSync = function harvestSync() {
   logger.info('Harvest finished.')
 }
 
-Agent.prototype._generateHarvestMetrics = function _generateHarvestMetrics() {
+Agent.prototype._beforeMetricDataSend = function _beforeMetricDataSend() {
+  this._generateEntityStatsAndClear()
+
+  // Send uninstrumented supportability metrics every metric harvest cycle
+  uninstrumented.createMetrics(this.metrics)
+}
+
+Agent.prototype._generateEntityStatsAndClear = function _generateHarvestMetrics() {
   // Note some information about the size of this harvest.
   if (logger.traceEnabled()) {
     logger.trace({
@@ -649,20 +578,12 @@ Agent.prototype._generateHarvestMetrics = function _generateHarvestMetrics() {
       harvestCreated: this.segmentsCreatedInHarvest,
       harvestCleared: this.segmentsClearedInHarvest,
       activeTransactions: this.activeTransactions
-    }, 'Entity stats on harvest')
+    }, 'Entity stats on metric harvest')
   }
-  this.recordSupportability(
-    'Nodejs/Transactions/Created',
-    this.transactionsCreatedInHarvest
-  )
-
-  // Send uninstrumented supportability metrics every harvest cycle
-  uninstrumented.createMetrics(this.metrics)
 
   // Reset the counters.
   this.segmentsCreatedInHarvest = 0
   this.segmentsClearedInHarvest = 0
-  this.transactionsCreatedInHarvest = 0
 }
 
 /**
@@ -702,94 +623,6 @@ Agent.prototype.canCollectData = function canCollectData() {
   return STATES[this._state]
 }
 
-/**
- * Server-side configuration value. When run, forces a harvest cycle
- * so as to not cause the agent to go too long without reporting.
- *
- * @param {number} interval Time in seconds between harvest runs.
- */
-Agent.prototype._harvesterIntervalChange = _harvesterIntervalChange
-
-function _harvesterIntervalChange(interval, callback) {
-  const agent = this
-
-  // only change the setup if the harvester is currently running
-  if (this.harvesterHandle) {
-    // force a harvest now, to be safe
-    this.harvest(function onHarvest(error) {
-      agent._restartHarvester(interval)
-      if (callback) callback(error)
-    })
-  } else if (callback) {
-    process.nextTick(callback)
-  }
-}
-
-/**
- * Restart the harvest cycle timer.
- *
- * @param {number} harvestSeconds How many seconds between harvests.
- */
-Agent.prototype._restartHarvester = function _restartHarvester(harvestSeconds) {
-  logger.trace('Restarting harvester.')
-
-  this._stopHarvester()
-  this._scheduleHarvester(harvestSeconds)
-}
-
-/**
- * Safely stop the harvest cycle timer.
- */
-Agent.prototype._stopHarvester = function _stopHarvester() {
-  logger.trace('Stopping harvester.')
-
-  if (this.harvesterHandle) {
-    clearTimeout(this.harvesterHandle)
-  }
-  this._lastHarvest = null
-  this.harvesterHandle = null
-}
-
-/**
- * Safely start the harvest cycle timer, and ensure that the harvest
- * cycle won't keep an application from exiting if nothing else is
- * happening to keep it up.
- *
- * @param {number} harvestSeconds - How many seconds between harvests.
- */
-Agent.prototype._scheduleHarvester = function _scheduleHarvester(harvestSeconds) {
-  // TODO: If this has to persist for an extended time, prevent rescheduling when
-  // agent is in a 'stopping' or 'stopped' state.
-
-  const agent = this
-  let harvestDelay = harvestSeconds * TO_MILLIS
-
-  // If there was a previous harvest, we want to schedule the next one based on
-  // its start time.
-  const lastHarvestStart = this._lastHarvest && this._lastHarvest.startTime
-  if (lastHarvestStart) {
-    const timeSinceHarvest = Date.now() - this._lastHarvest.startTime
-    harvestDelay = Math.max(0, harvestDelay - timeSinceHarvest)
-  }
-
-  logger.trace(
-    'Scheduling harvester. ' +
-    `Last harvest start: ${lastHarvestStart}. Next harvest delay: ${harvestDelay}`
-  )
-
-  this.harvesterHandle = setTimeout(function doHarvest() {
-    // Agent#harvest handles scheduling the next harvest and properly reacting to
-    // any errors or commands. All we need to do is note any errors it spits out.
-    agent.harvest(function harvestError(error) {
-      if (error) {
-        logger.warn(error, 'Error on submission to New Relic.')
-      }
-    })
-  }, harvestDelay)
-
-  this.harvesterHandle.unref()
-}
-
 /**
  * `agent_enabled` changed. This will generally only happen because of a high
  * security mode mismatch between the agent and the collector. This only

package/lib/aggregators/base-aggregator.js

@@ -19,24 +19,20 @@ class Aggregator extends EventEmitter {
   }
 
   start() {
-    // TODO: log something useful on start?
     logger.trace(`${this.method} aggregator started.`)
 
     if (!this.sendTimer) {
-      // TODO: need to keep track of start time / last harvest?
-
       this.sendTimer = setInterval(this.send.bind(this), this.periodMs)
       this.sendTimer.unref()
     }
   }
 
   stop() {
-    logger.trace(`${this.method} aggregator stopped.`)
-
     if (this.sendTimer) {
-      // TODO: log something useful on stop
       clearInterval(this.sendTimer)
       this.sendTimer = null
+
+      logger.trace(`${this.method} aggregator stopped.`)
     }
   }
 
@@ -74,11 +70,6 @@ class Aggregator extends EventEmitter {
 
   _runSend(data, payload) {
     if (!payload) {
-      // TODO: log something about no data to send.
-      // or maybe not since handled in topayload?
-      // maybe do just here?
-      // May be better to handle ont he tranport side
-      // as a consistent spot
       this._afterSend(false)
       this.emit(`finished ${this.method} data send.`)
       return
@@ -97,7 +88,6 @@ class Aggregator extends EventEmitter {
   }
 
   send() {
-    // TODO: log?
     logger.info(`${this.method} Aggregator data send.`)
     this.emit(`starting ${this.method} data send.`)
 
@@ -109,6 +99,7 @@ class Aggregator extends EventEmitter {
     } else {
       this._runSend(data, this._toPayloadSync())
     }
+
     this.clear()
   }
 

package/lib/collector/api.js

@@ -469,7 +469,8 @@ CollectorAPI.prototype.restart = function restart(callback) {
 CollectorAPI.prototype._runLifecycle = function _runLifecycle(method, body, callback) {
   if (!this.isConnected()) {
     logger.warn('Not connected to New Relic. Not calling.', method.name)
-    return callback(new Error('Not connected to collector.', null, null))
+    const error = new Error('Not connected to collector.', null, null)
+    return setImmediate(callback, error)
   }
 
   const api = this

package/lib/collector/facts.js

@@ -52,7 +52,7 @@ function facts(agent, callback) {
 
     results.event_harvest_config = {
       harvest_limits: {
-        analytic_event_data: agent.config.transaction_events.max_samples_per_minute,
+        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

package/lib/config/default.js

@@ -179,6 +179,13 @@ exports.config = () => ({
     filter_cache_limit: 1000
   },
 
+  diagnostics: {
+    code_injector: {
+      enabled: false,
+      internal_file_pattern: /nodejs_agent\/(?:(?!test))|\/node_modules\/(?:@)?newrelic/
+    }
+  },
+
   logging: {
     /**
      * Verbosity of the module's logging. This module uses bunyan
@@ -655,17 +662,7 @@ exports.config = () => ({
      * The agent will collect all events up to this number per minute. If
      * there are more than that, a statistical sampling will be collected.
      */
-    max_samples_per_minute: 10000,
-    /**
-     * This is used if the agent is unable to send events to the collector.
-     * The values from the previous harvest cycle will be merged into the next
-     * one with this option as the limit.
-     *
-     * This should be *greater* than max_samples_per_minute or you'll see odd
-     * behavior. You probably want at least double the value, but more is okay
-     * as long as you can handle the memory overhead.
-     */
-    max_samples_stored: 20000
+    max_samples_stored: 10000
   },
 
   /**