newrelic 5.9.1 → 5.13.1

package/lib/agent.js

@@ -4,27 +4,27 @@ const AdaptiveSampler = require('./adaptive-sampler')
 const CollectorAPI = require('./collector/api')
 const ServerlessCollector = require('./collector/serverless')
 const DESTINATIONS = require('./config/attribute-filter').DESTINATIONS
-const ErrorAggregator = require('./errors/aggregator')
+const CustomEventAggregator = require('./custom-events/custom-event-aggregator')
+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')
 const MetricNormalizer = require('./metrics/normalizer')
-const Metrics = require('./metrics')
+const MetricAggregator = require('./metrics/metric-aggregator')
 const NAMES = require('./metrics/names')
-const PriorityQueue = require('./priority-queue')
-const QueryTracer = require('./db/tracer')
+const QueryTraceAggregator = require('./db/query-trace-aggregator')
 const sampler = require('./sampler')
-const SpanAggregator = require('./spans/aggregator')
-const TraceAggregator = require('./transaction/trace/aggregator')
+const TransactionTraceAggregator = require('./transaction/trace/aggregator')
+const SpanEventAggregator = require('./spans/span-event-aggregator')
+const TransactionEventAggregator = require('./transaction/transaction-event-aggregator')
 const Tracer = require('./transaction/tracer')
 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,
@@ -37,8 +37,9 @@ 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
 
 /**
  * There's a lot of stuff in this constructor, due to Agent acting as the
@@ -65,24 +66,94 @@ function Agent(config) {
     this.collector = new CollectorAPI(this)
   }
 
-  // Reset the agent to add all the sub-objects it needs. These object are the
-  // ones that get re-created if the agent is told to restart from the collector.
-  this.events = null
-  this.customEvents = null
-  this.errors = null
-  this.mapper = null
-  this.metricNameNormalizer = null
-  this.metrics = null
-  this.spans = null
-  this.transactionNameNormalizer = null
-  this.txSegmentNormalizer = null
-  this.urlNormalizer = null
-  this.userNormalizer = null
-  this.reset()
+  this.mapper = new MetricMapper()
+  this.metricNameNormalizer = new MetricNormalizer(this.config, 'metric name')
+
+  this.metrics = new MetricAggregator(
+    {
+      periodMs: DEFAULT_HARVEST_INTERVAL_MS,
+      apdexT: this.config.apdex_t,
+      mapper: this.mapper,
+      normalizer: this.metricNameNormalizer
+    },
+    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,
+    limit: config.event_harvest_config.harvest_limits.span_event_data
+  },
+  this.collector,
+  this.metrics)
+
+  this.transactionNameNormalizer = new MetricNormalizer(this.config, 'transaction name')
+  // Segment term based tx renaming for MGI mitigation.
+  this.txSegmentNormalizer = new TxSegmentNormalizer()
+
+  // User naming and ignoring rules.
+  this.urlNormalizer = new MetricNormalizer(this.config, 'URL')
+  this.userNormalizer = new MetricNormalizer(this.config, 'user')
+  this.userNormalizer.loadFromConfig()
+
+  this.transactionEventAggregator = new TransactionEventAggregator(
+    {
+      periodMs: config.event_harvest_config.report_period_ms,
+      limit: config.event_harvest_config.harvest_limits.analytic_event_data
+    },
+    this.collector,
+    this.metrics
+  )
+
+  this.customEventAggregator = new CustomEventAggregator(
+    {
+      periodMs: config.event_harvest_config.report_period_ms,
+      limit: config.event_harvest_config.harvest_limits.custom_event_data
+    },
+    this.collector,
+    this.metrics
+  )
+
+  const errorTraceAggregator = new ErrorTraceAggregator(
+    {
+      periodMs: DEFAULT_HARVEST_INTERVAL_MS,
+      limit: MAX_ERROR_TRACES_DEFAULT
+    },
+    this.collector
+  )
+
+  const errorEventAggregator =  new ErrorEventAggregator(
+    {
+      periodMs: config.event_harvest_config.report_period_ms,
+      limit: config.event_harvest_config.harvest_limits.error_event_data
+    },
+    this.collector,
+    this.metrics
+  )
+
+  this.errors = new ErrorCollector(
+    config,
+    errorTraceAggregator,
+    errorEventAggregator,
+    this.metrics
+  )
 
   // Transaction tracing.
   this.tracer = new Tracer(this)
-  this.traces = new TraceAggregator(this.config)
+  this.traces = new TransactionTraceAggregator(
+    {
+      periodMs: DEFAULT_HARVEST_INTERVAL_MS,
+      config: this.config,
+      isAsync: !config.serverless_mode.enabled,
+      method: 'transaction_sample_data'
+    },
+    this.collector
+  )
   this.transactionSampler = new AdaptiveSampler({
     agent: this,
     serverless: config.serverless_mode.enabled,
@@ -90,8 +161,15 @@ function Agent(config) {
     target: config.sampling_target
   })
 
-  // Query tracing.
-  this.queries = new QueryTracer(this.config)
+  this.queries = new QueryTraceAggregator(
+    {
+      config: this.config,
+      periodMs: DEFAULT_HARVEST_INTERVAL_MS,
+      method: 'sql_trace_data',
+      isAsync: !config.serverless_mode.enabled
+    },
+    this.collector
+  )
 
   // Set up all the configuration events the agent needs to listen for.
   this._listenForConfigChanges()
@@ -100,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))
@@ -153,10 +227,9 @@ Agent.prototype.start = function start(callback) {
       callback(new Error('Not starting without license key!'))
     })
   }
-
   logger.info('Starting New Relic for Node.js connection process.')
 
-  this.collector.connect(function onConnect(error, response) {
+  this.collector.connect(function onStartConnect(error, response) {
     if (error || response.shouldShutdownRun()) {
       agent.setState('errored')
       sampler.stop()
@@ -168,10 +241,12 @@ Agent.prototype.start = function start(callback) {
     }
 
     if (agent.collector.isConnected()) {
+      agent.onConnect()
       agent.setState('started')
       const config = response.payload
+
       if (agent.config.no_immediate_harvest) {
-        agent._scheduleHarvester(agent.config.data_report_period)
+        agent.startAggregators()
         callback(null, config)
       } else {
         // Harvest immediately for quicker data display, but after at least 1
@@ -180,10 +255,13 @@ Agent.prototype.start = function start(callback) {
         // NOTE: this setTimeout is deliberately NOT unref'd due to it being
         // the last step in the Agent startup process
         setTimeout(function afterTimeout() {
-          agent.harvest(function onHarvest(harvestError) {
-            callback(harvestError, config)
+          logger.info(`Starting initial ${INITIAL_HARVEST_DELAY_MS}ms harvest.`)
+
+          agent.forceHarvestAll(function afterAllAggregatorsSend() {
+            agent.startAggregators()
+            callback(null, config)
           })
-        }, 1000)
+        }, INITIAL_HARVEST_DELAY_MS)
       }
     } else {
       callback(new Error('Collector did not connect and did not error'))
@@ -191,6 +269,181 @@ 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()
+  this.traces.stop()
+  this.queries.stop()
+  this.spanEventAggregator.stop()
+  this.transactionEventAggregator.stop()
+  this.customEventAggregator.stop()
+}
+
+Agent.prototype.startAggregators = function startAggregators() {
+  this.metrics.start()
+  this.errors.start()
+  if (this.config.transaction_tracer.enabled && this.config.collect_traces) {
+    this.traces.start()
+  }
+
+  if (this.config.slow_sql.enabled) {
+    this.queries.start()
+  }
+
+  if (this.config.distributed_tracing.enabled &&
+      this.config.span_events.enabled) {
+    this.spanEventAggregator.start()
+  }
+
+  if (this.config.transaction_events.enabled) {
+    this.transactionEventAggregator.start()
+  }
+
+  if (this.config.custom_insights_events.enabled) {
+    this.customEventAggregator.start()
+  }
+}
+
+Agent.prototype.onConnect = function onConnect() {
+  this.metrics.reconfigure(this.config)
+  this.errors.reconfigure(this.config)
+  this.traces.reconfigure(this.config)
+  this.queries.reconfigure(this.config)
+  this.spanEventAggregator.reconfigure(this.config)
+  this.transactionEventAggregator.reconfigure(this.config)
+  this.customEventAggregator.reconfigure(this.config)
+}
+
 /**
  *  Bypasses standard collector connection by immediately invoking the startup
  *  callback, after gathering local environment details.
@@ -218,7 +471,9 @@ Agent.prototype.stop = function stop(callback) {
   const agent = this
 
   this.setState('stopping')
-  this._stopHarvester()
+
+  this.stopAggregators()
+
   sampler.stop()
 
   if (this.collector.isConnected()) {
@@ -234,32 +489,24 @@ Agent.prototype.stop = function stop(callback) {
       callback(error)
     })
   } else {
+    logger.trace('Collector was not connected, invoking callback.')
+
     process.nextTick(callback)
   }
 }
 
 /**
  * Resets queries.
- *
- * @param {boolean} forceReset
- *   Flag signalling unconditional reset, sent during LASP application.
  */
-Agent.prototype._resetQueries = function resetQueries(forceReset) {
-  if (!this.queries || forceReset) {
-    this.queries = new QueryTracer(this.config)
-  }
+Agent.prototype._resetQueries = function resetQueries() {
+  this.queries.clear()
 }
 
-/**
- * Resets errors.
- *
- * @param {boolean} forceReset
- *   Flag signalling unconditional reset, sent during LASP application.
- */
-Agent.prototype._resetErrors = function resetErrors(forceReset) {
-  if (!this.errors || forceReset) {
-    this.errors = new ErrorAggregator(this.config)
-  }
+Agent.prototype._resetErrors = function resetErrors() {
+  this.errors.clearAll()
+
+  // TODO: is this still necessary?
+  // Likely do more direct with new config
   this.errors.reconfigure(this.config)
 }
 
@@ -267,15 +514,7 @@ Agent.prototype._resetErrors = function resetErrors(forceReset) {
  * Resets events.
  */
 Agent.prototype._resetEvents = function resetEvents() {
-  if (!this.events) {
-    this.events = new PriorityQueue()
-  }
-
-  this.events.setLimit(this.config.transaction_events.max_samples_per_minute)
-
-  if (!this.customEvents) {
-    this.customEvents = new PriorityQueue()
-  }
+  this.transactionEventAggregator.clear()
 }
 
 /**
@@ -284,105 +523,8 @@ Agent.prototype._resetEvents = function resetEvents() {
  * @param {boolean} forceReset
  *   Flag signalling unconditional reset, sent during LASP application.
  */
-Agent.prototype._resetCustomEvents = function resetCustomEvents(forceReset) {
-  if (!this.customEvents || forceReset) {
-    this.customEvents = new PriorityQueue()
-  }
-
-  this.customEvents.setLimit(this.config.custom_insights_events.max_samples_stored)
-}
-
-/**
- * Builds all of the sub-properties of the agent that rely on configurations.
- */
-Agent.prototype.reset = function reset() {
-  // Insights events.
-  this._resetEvents()
-  this._resetCustomEvents()
-
-  // Error tracing.
-  this._resetErrors()
-
-  // Open tracing.
-  this.spans = new SpanAggregator()
-
-  // Metrics.
-  this.mapper = new MetricMapper()
-  this.metricNameNormalizer = new MetricNormalizer(this.config, 'metric name')
-  this.metrics = new Metrics(this.config.apdex_t, this.mapper, this.metricNameNormalizer)
-
-  // Transaction naming.
-  this.transactionNameNormalizer = new MetricNormalizer(this.config, 'transaction name')
-  this.urlNormalizer = new MetricNormalizer(this.config, 'URL')
-
-  // Segment term based tx renaming for MGI mitigation.
-  this.txSegmentNormalizer = new TxSegmentNormalizer()
-
-  // User naming and ignoring rules.
-  this.userNormalizer = new MetricNormalizer(this.config, 'user')
-  this.userNormalizer.loadFromConfig()
-}
-
-/**
- * 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) {
-  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()) {
-    return setImmediate(function immediatelyError() {
-      callback(new Error('Not connected to New Relic!'))
-    })
-  }
-
-  // We have a connection, create a new harvest.
-  this.emit('harvestStarted')
-  this._lastHarvest = new Harvest(this)
-  this._lastHarvest.prepare(Harvest.ALL_ENDPOINTS)
-
-  // Reset all our collections. The harvest has all the data it needs at this point.
-  this._resetHarvestables()
-
-  // Send the harvest!
-  const collector = this.collector
-  const agent = this
-  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')
-      agent.stop(function afterStop(stopError) {
-        const shutdownError = stopError || err
-        callback(shutdownError)
-      })
-    } else if (agentRunAction === AGENT_RUN_BEHAVIOR.RESTART) {
-      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 {
-          _finish(err)
-        }
-      })
-    } else {
-      _finish(err)
-    }
-
-    function _finish(error) {
-      agent.emit('harvestFinished')
-      agent._scheduleHarvester(agent.config.data_report_period)
-      callback(error)
-    }
-  })
+Agent.prototype._resetCustomEvents = function resetCustomEvents() {
+  this.customEventAggregator.clear()
 }
 
 /**
@@ -391,78 +533,57 @@ Agent.prototype.harvest = function harvest(callback) {
  * NOTE: this doesn't currently work outside of serverless mode.
  */
 Agent.prototype.harvestSync = function harvestSync() {
-  // Generate metrics for this harvest and then check we are connected to the
-  // collector.
-  this._generateHarvestMetrics()
+  logger.trace('Peparing to harvest.')
 
   if (!this.collector.isConnected()) {
-    throw new Error('Not connected to New Relic!')
+    throw new Error('Sync harvest not connected/enabled!')
   }
 
   // We have a connection, create a new harvest.
   this.emit('harvestStarted')
-  this._lastHarvest = new Harvest(this)
-  this._lastHarvest.prepare(Harvest.ALL_ENDPOINTS)
-
-  // Reset all our collections. The harvest has all the data it needs at this point.
-  this._resetHarvestables()
+  logger.info('Harvest started.')
 
   const collector = this.collector
   const agent = this
 
-  // Collect and send payload data
-  const payloads = this._lastHarvest.getPayloads()
-  collector.populateDataSync(payloads)
+  // "Sends" data to the serverless collector collection
+  this.metrics.send()
+  this.errors.traceAggregator.send()
+  this.errors.eventAggregator.send()
+  this.traces.send()
+  this.queries.send()
+  this.spanEventAggregator.send()
+  this.transactionEventAggregator.send()
+  this.customEventAggregator.send()
+
+  // Write serverless output
   collector.flushPayloadSync()
+
   agent.emit('harvestFinished')
+  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({
       segmentTotal: this.totalActiveSegments,
       harvestCreated: this.segmentsCreatedInHarvest,
       harvestCleared: this.segmentsClearedInHarvest,
-      activeTransactions: this.activeTransactions,
-      spansCollected: this.spans.length,
-      spansSeen: this.spans.seen
-    }, 'Entity stats on harvest')
-  }
-  this.recordSupportability(
-    'Nodejs/Transactions/Created',
-    this.transactionsCreatedInHarvest
-  )
-
-  // Send uninstrumented supportability metrics every harvest cycle
-  uninstrumented.createMetrics(this.metrics)
+      activeTransactions: this.activeTransactions
+    }, 'Entity stats on metric harvest')
+  }
 
   // Reset the counters.
   this.segmentsCreatedInHarvest = 0
   this.segmentsClearedInHarvest = 0
-  this.transactionsCreatedInHarvest = 0
-}
-
-Agent.prototype._resetHarvestables = function _resetHarvestables() {
-  // TODO: Make each aggregator able to compose its own payload and clean itself
-  // up. Then the Harvest class can just iterate over all aggregations without
-  // having to know bespoke reset information.
-  this.metrics = new Metrics(
-    this.config.apdex_t,
-    this.mapper,
-    this.metricNameNormalizer
-  )
-  this.events = new PriorityQueue(this.config.transaction_events.max_samples_per_minute)
-
-  this.customEvents = new PriorityQueue(
-    this.config.custom_insights_events.max_samples_stored
-  )
-
-  this.errors.clearEvents()
-  this.errors.clearErrors()
-  this.traces.reset()
-  this.queries = new QueryTracer(this.config)
-  this.spans.clearEvents()
 }
 
 /**
@@ -489,7 +610,7 @@ Agent.prototype.setState = function setState(newState) {
     throw new TypeError('Invalid state ' + newState)
   }
 
-  logger.debug('Agent state changed from %s to %s.', this._state, newState)
+  logger.info('Agent state changed from %s to %s.', this._state, newState)
   this._state = newState
   this.emit(this._state)
 }
@@ -502,90 +623,6 @@ Agent.prototype.canCollectData = function canCollectData() {
   return STATES[this._state]
 }
 
-/**
- * Server-side configuration value.
- *
- * @param {number} apdexT Apdex tolerating value, in seconds.
- */
-Agent.prototype._apdexTChange = function _apdexTChange(apdexT) {
-  logger.debug('Apdex tolerating value changed to %s.', apdexT)
-  this.metrics.apdexT = apdexT
-}
-
-/**
- * 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) {
-  this._stopHarvester()
-  this._scheduleHarvester(harvestSeconds)
-}
-
-/**
- * Safely stop the harvest cycle timer.
- */
-Agent.prototype._stopHarvester = function _stopHarvester() {
-  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) {
-  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.
-  if (this._lastHarvest && this._lastHarvest.startTime) {
-    const timeSinceHarvest = Date.now() - this._lastHarvest.startTime
-    harvestDelay = Math.max(0, harvestDelay - timeSinceHarvest)
-  }
-
-  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
@@ -715,7 +752,7 @@ Agent.prototype._addEventFromTransaction = function _addEventFromTransaction(tx)
     agentAttributes
   ]
 
-  this.events.add(event, tx.priority || Math.random())
+  this.transactionEventAggregator.add(event, tx.priority || Math.random())
 }
 
 /**
@@ -734,8 +771,10 @@ Agent.prototype._transactionFinished = function _transactionFinished(transaction
     if (transaction.forceIgnore === false) {
       logger.debug('Explicitly not ignoring %s (%s).', transaction.name, transaction.id)
     }
-    this.metrics.merge(transaction.metrics)
-    this.errors.onTransactionFinished(transaction, this.metrics)
+    this.metrics.merge(transaction.metrics, false)
+
+    this.errors.onTransactionFinished(transaction)
+
     this.traces.add(transaction)
 
     const trace = transaction.trace
@@ -779,7 +818,6 @@ Agent.prototype.recordSupportability = function recordSupportability(name, value
 
 Agent.prototype._listenForConfigChanges = function _listenForConfigChanges() {
   const self = this
-  this.config.on('apdex_t', this._apdexTChange.bind(this))
   this.config.on('agent_enabled', this._enabledChange.bind(this))
   this.config.on('change', this._configChange.bind(this))
   this.config.on('metric_name_rules', function updateMetricNameNormalizer() {
@@ -803,12 +841,47 @@ Agent.prototype._listenForConfigChanges = function _listenForConfigChanges() {
       self.transactionSampler.samplingPeriod = period * 1000
     }
   )
-  this.config.on(
-    'transaction_events.max_samples_per_minute',
-    function updateEventSampleLimit(maxSamples) {
-      self.events.setLimit(maxSamples)
+  this.config.on('event_harvest_config', function onHarvestConfigReceived(harvestConfig) {
+    if (harvestConfig) {
+      generateEventHarvestSupportMetrics(self, harvestConfig)
     }
-  )
+  })
+}
+
+function generateEventHarvestSupportMetrics(agent, harvestConfig) {
+  const harvestLimits = harvestConfig.harvest_limits
+
+  const harvestNames = NAMES.EVENT_HARVEST
+  const harvestLimitNames = harvestNames.HARVEST_LIMIT
+
+  const reportPeriodMetric = agent.metrics.getOrCreateMetric(harvestNames.REPORT_PERIOD)
+  reportPeriodMetric.recordValue(harvestConfig.report_period_ms)
+
+  const analyticLimit = harvestLimits.analytic_event_data
+  if (analyticLimit) {
+    const analyticLimitMetric = agent.metrics.getOrCreateMetric(
+      harvestLimitNames.ANALYTIC
+    )
+    analyticLimitMetric.recordValue(analyticLimit)
+  }
+
+  const customLimit = harvestLimits.custom_event_data
+  if (customLimit) {
+    const customLimitMetric = agent.metrics.getOrCreateMetric(harvestLimitNames.CUSTOM)
+    customLimitMetric.recordValue(customLimit)
+  }
+
+  const errorLimit = harvestLimits.error_event_data
+  if (errorLimit) {
+    const errorLimitMetric = agent.metrics.getOrCreateMetric(harvestLimitNames.ERROR)
+    errorLimitMetric.recordValue(errorLimit)
+  }
+
+  const spanLimit = harvestLimits.span_event_data
+  if (spanLimit) {
+    const spanLimitMetric = agent.metrics.getOrCreateMetric(harvestLimitNames.SPAN)
+    spanLimitMetric.recordValue(spanLimit)
+  }
 }
 
 module.exports = Agent