newrelic 4.10.0 → 4.13.1

package/lib/agent.js

@@ -2,6 +2,7 @@
 
 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 EventEmitter = require('events').EventEmitter
@@ -22,9 +23,11 @@ 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
 const STATES = [
   'stopped',      // start state
-  'starting',     // handshaking with NR
+  'starting',     // starting agent
+  'connecting',   // handshaking with NR
   'connected',    // connected to collector
   'disconnected', // disconnected from collector
   'started',      // up and running
@@ -34,6 +37,7 @@ const STATES = [
 
 // just to make clear what's going on
 const TO_MILLIS = 1e3
+const SERVERLESS_SAMPLING_LIMIT = Infinity
 
 /**
  * There's a lot of stuff in this constructor, due to Agent acting as the
@@ -53,7 +57,12 @@ function Agent(config) {
   this.config = config
   this.environment = require('./environment')
   this.version = this.config.version
-  this.collector = new CollectorAPI(this)
+
+  if (config.serverless_mode.enabled) {
+    this.collector = new ServerlessCollector(this)
+  } else {
+    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.
@@ -74,6 +83,8 @@ function Agent(config) {
   this.tracer = new Tracer(this)
   this.traces = new TraceAggregator(this.config)
   this.transactionSampler = new AdaptiveSampler({
+    agent: this,
+    serverless: config.serverless_mode.enabled,
     period: config.sampling_target_period_in_seconds * 1000,
     target: config.sampling_target
   })
@@ -112,7 +123,7 @@ util.inherits(Agent, EventEmitter)
 Agent.prototype.start = function start(callback) {
   if (!callback) throw new TypeError('callback required!')
 
-  var agent = this
+  const agent = this
 
   this.setState('starting')
 
@@ -124,50 +135,75 @@ Agent.prototype.start = function start(callback) {
     return process.nextTick(callback)
   }
 
-  if (!(this.config.license_key)) {
+  sampler.start(agent)
+
+  if (this.config.serverless_mode.enabled) {
+    return this._serverlessModeStart(callback)
+  }
+
+  if (!this.config.license_key) {
     logger.error('A valid account license key cannot be found. ' +
                  'Has a license key been specified in the agent configuration ' +
                  'file or via the NEW_RELIC_LICENSE_KEY environment variable?')
 
     this.setState('errored')
+    sampler.stop()
     return process.nextTick(function onNextTick() {
       callback(new Error('Not starting without license key!'))
     })
   }
 
-  sampler.start(agent)
-
   logger.info('Starting New Relic for Node.js connection process.')
 
-  this.collector.connect(function onConnect(error, config) {
-    if (error) {
+  this.collector.connect(function onConnect(error, response) {
+    if (error || response.shouldShutdownRun()) {
       agent.setState('errored')
       sampler.stop()
-      return callback(error, config)
+      callback(
+        error || new Error('Failed to connect to collector'),
+        response && response.payload
+      )
+      return
     }
 
-    if (agent.collector.isConnected() && !agent.config.no_immediate_harvest) {
-      // harvest immediately for quicker data display, but after at least 1
-      // second or the collector will throw away the data.
-      //
-      // 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) {
-          agent._startHarvester(agent.config.data_report_period)
-
-          agent.setState('started')
-          callback(harvestError, config)
-        })
-      }, 1000)
-    } else {
-      process.nextTick(function onNextTick() {
+    if (agent.collector.isConnected()) {
+      agent.setState('started')
+      const config = response.payload
+      if (agent.config.no_immediate_harvest) {
+        agent._scheduleHarvester(agent.config.data_report_period)
         callback(null, config)
-      })
+      } else {
+        // Harvest immediately for quicker data display, but after at least 1
+        // second or the collector will throw away the data.
+        //
+        // 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)
+          })
+        }, 1000)
+      }
+    } else {
+      callback(new Error('Collector did not connect and did not error'))
     }
   })
 }
 
+/**
+ *  Bypasses standard collector connection by immediately invoking the startup
+ *  callback, after gathering local environment details.
+ *
+ * @param {Function} callback
+ */
+Agent.prototype._serverlessModeStart = function _serverlessModeStart(callback) {
+  logger.info(
+    'New Relic for Node.js starting in serverless mode -- skipping connection process.'
+  )
+
+  setImmediate(() => callback(null, this.config))
+}
+
 /**
  * Any memory claimed by the agent will be retained after stopping.
  *
@@ -178,7 +214,7 @@ Agent.prototype.start = function start(callback) {
 Agent.prototype.stop = function stop(callback) {
   if (!callback) throw new TypeError('callback required!')
 
-  var agent = this
+  const agent = this
 
   this.setState('stopping')
   this._stopHarvester()
@@ -233,7 +269,13 @@ Agent.prototype._resetEvents = function resetEvents() {
   if (!this.events) {
     this.events = new PriorityQueue()
   }
-  this.events.setLimit(this.config.transaction_events.max_samples_per_minute)
+
+  this.events.setLimit(
+    this.config.serverless_mode.enabled
+      ? SERVERLESS_SAMPLING_LIMIT
+      : this.config.transaction_events.max_samples_per_minute
+  )
+
   if (!this.customEvents) {
     this.customEvents = new PriorityQueue()
   }
@@ -249,7 +291,12 @@ 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)
+
+  this.customEvents.setLimit(
+    this.config.serverless_mode.enabled
+      ? SERVERLESS_SAMPLING_LIMIT
+      : this.config.custom_insights_events.max_samples_stored
+  )
 }
 
 /**
@@ -264,7 +311,11 @@ Agent.prototype.reset = function reset() {
   this._resetErrors()
 
   // Open tracing.
-  this.spans = new SpanAggregator()
+  this.spans = new SpanAggregator(
+    this.config.serverless_mode.enabled
+      ? SERVERLESS_SAMPLING_LIMIT
+      : null
+  )
 
   // Metrics.
   this.mapper = new MetricMapper()
@@ -305,31 +356,54 @@ Agent.prototype.harvest = function harvest(callback) {
   }
 
   // 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.
-  // 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()
+  this._resetHarvestables()
 
   // Send the harvest!
-  this._lastHarvest.send(callback)
+  const collector = this.collector
+  const agent = this
+  this._lastHarvest.send(function afterHarvest(err, agentRunAction) {
+    // The serverless collector will never tell us anything interesting to do,
+    // but has an awkward, final step that the normal collector does not.
+    if (collector instanceof ServerlessCollector) {
+      return collector.flushPayload(function afterFlush(flushError) {
+        agent.emit('harvestFinished')
+        const serverlessError = flushError || err
+        callback(serverlessError)
+      })
+    }
+
+    // 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._generateHarvestMetrics = function _generateHarvestMetrics() {
@@ -358,6 +432,32 @@ Agent.prototype._generateHarvestMetrics = function _generateHarvestMetrics() {
   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.serverless_mode.enabled
+      ? SERVERLESS_SAMPLING_LIMIT
+      : this.config.transaction_events.max_samples_per_minute
+  )
+  this.customEvents = new PriorityQueue(
+    this.config.serverless_mode.enabled
+      ? SERVERLESS_SAMPLING_LIMIT
+      : 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()
+}
+
 /**
  * Public interface for passing configuration data from the collector
  * on to the configuration, in an effort to keep them at least somewhat
@@ -407,7 +507,7 @@ Agent.prototype._apdexTChange = function _apdexTChange(apdexT) {
 Agent.prototype._harvesterIntervalChange = _harvesterIntervalChange
 
 function _harvesterIntervalChange(interval, callback) {
-  var agent = this
+  const agent = this
 
   // only change the setup if the harvester is currently running
   if (this.harvesterHandle) {
@@ -428,14 +528,17 @@ function _harvesterIntervalChange(interval, callback) {
  */
 Agent.prototype._restartHarvester = function _restartHarvester(harvestSeconds) {
   this._stopHarvester()
-  this._startHarvester(harvestSeconds)
+  this._scheduleHarvester(harvestSeconds)
 }
 
 /**
  * Safely stop the harvest cycle timer.
  */
 Agent.prototype._stopHarvester = function _stopHarvester() {
-  if (this.harvesterHandle) clearInterval(this.harvesterHandle)
+  if (this.harvesterHandle) {
+    clearTimeout(this.harvesterHandle)
+  }
+  this._lastHarvest = null
   this.harvesterHandle = null
 }
 
@@ -444,22 +547,28 @@ Agent.prototype._stopHarvester = function _stopHarvester() {
  * 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.
+ * @param {number} harvestSeconds - How many seconds between harvests.
  */
-Agent.prototype._startHarvester = function _startHarvester(harvestSeconds) {
-  var agent = this
-
-  function onError(error) {
-    if (error) {
-      logger.info(error, 'Error on submission to New Relic (data held for redelivery):')
-    }
+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)
   }
 
-  function harvester() {
-    agent.harvest(onError)
-  }
-
-  this.harvesterHandle = setInterval(harvester, harvestSeconds * TO_MILLIS)
+  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()
 }
 
@@ -487,17 +596,17 @@ Agent.prototype._configChange = function _configChange() {
 Agent.prototype._addIntrinsicAttrsFromTransaction = _addIntrinsicAttrsFromTransaction
 
 function _addIntrinsicAttrsFromTransaction(transaction) {
-  var intrinsicAttributes = {
+  const intrinsicAttributes = {
     webDuration: transaction.timer.getDurationInMillis() / 1000,
     timestamp: transaction.timer.start,
     name: transaction.getFullName(),
     duration: transaction.timer.getDurationInMillis() / 1000,
-    totalTime: transaction.trace.getTotalTimeDurationInMillis(),
+    totalTime: transaction.trace.getTotalTimeDurationInMillis() / 1000,
     type: 'Transaction',
     error: transaction.hasErrors()
   }
 
-  var metric = transaction.metrics.getMetric(NAMES.QUEUETIME)
+  let metric = transaction.metrics.getMetric(NAMES.QUEUETIME)
   if (metric) {
     intrinsicAttributes.queueDuration = metric.total
   }
@@ -582,11 +691,11 @@ function calculateApdexZone(duration, apdexT) {
 Agent.prototype._addEventFromTransaction = function _addEventFromTransaction(tx) {
   if (!this.config.transaction_events.enabled) return
 
-  var intrinsicAttributes = this._addIntrinsicAttrsFromTransaction(tx)
-  var userAttributes = tx.trace.custom.get(DESTINATIONS.TRANS_EVENT)
-  var agentAttributes = tx.trace.attributes.get(DESTINATIONS.TRANS_EVENT)
+  const intrinsicAttributes = this._addIntrinsicAttrsFromTransaction(tx)
+  const userAttributes = tx.trace.custom.get(DESTINATIONS.TRANS_EVENT)
+  const agentAttributes = tx.trace.attributes.get(DESTINATIONS.TRANS_EVENT)
 
-  var event = [
+  const event = [
     intrinsicAttributes,
     userAttributes,
     agentAttributes
@@ -615,7 +724,7 @@ Agent.prototype._transactionFinished = function _transactionFinished(transaction
     this.errors.onTransactionFinished(transaction, this.metrics)
     this.traces.add(transaction)
 
-    var trace = transaction.trace
+    const trace = transaction.trace
     trace.intrinsics = transaction.getIntrinsicAttributes()
 
     this._addEventFromTransaction(transaction)
@@ -628,6 +737,20 @@ Agent.prototype._transactionFinished = function _transactionFinished(transaction
   --this.activeTransactions
   this.totalActiveSegments -= transaction.numSegments
   this.segmentsClearedInHarvest += transaction.numSegments
+
+  if (this.config.serverless_mode.enabled) {
+    this.harvest(function onServerlessHarvest(err) {
+      if (err) {
+        logger.error('Serverless mode harvest error', err)
+      }
+    })
+  }
+}
+
+Agent.prototype.setLambdaArn = function setLambdaArn(arn) {
+  if (this.collector instanceof ServerlessCollector) {
+    this.collector.setLambdaArn(arn)
+  }
 }
 
 /**
@@ -640,7 +763,7 @@ Agent.prototype.getTransaction = function getTransaction() {
 }
 
 Agent.prototype.recordSupportability = function recordSupportability(name, value) {
-  var metric = this.metrics.getOrCreateMetric(NAMES.SUPPORTABILITY.PREFIX + name)
+  const metric = this.metrics.getOrCreateMetric(NAMES.SUPPORTABILITY.PREFIX + name)
   if (value != null) {
     metric.recordValue(value)
   } else {
@@ -649,9 +772,8 @@ Agent.prototype.recordSupportability = function recordSupportability(name, value
 }
 
 Agent.prototype._listenForConfigChanges = function _listenForConfigChanges() {
-  var self = this
+  const self = this
   this.config.on('apdex_t', this._apdexTChange.bind(this))
-  this.config.on('data_report_period', this._harvesterIntervalChange.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() {