newrelic 9.6.0 → 9.7.1

package/lib/collector/api.js

@@ -5,6 +5,7 @@
 
 'use strict'
 
+const http = require('http')
 const CollectorResponse = require('./response')
 const facts = require('./facts')
 const logger = require('../logger').child({ component: 'collector_api' })
@@ -36,8 +37,8 @@ const FAILURE_DISCARD_DATA = new Set([400, 403, 404, 405, 407, 411, 413, 414, 41
 const AGENT_RUN_BEHAVIOR = CollectorResponse.AGENT_RUN_BEHAVIOR
 
 /**
- * @param errors
- * @param name
+ * @param {Array} errors list of errors
+ * @param {string} name collector endpoint name
  */
 function dumpErrors(errors, name) {
   let index = 1
@@ -54,7 +55,7 @@ function dumpErrors(errors, name) {
 }
 
 /**
- * @param agent
+ * @param {Agent} agent New Relic agent
  */
 function CollectorAPI(agent) {
   this._agent = agent
@@ -89,11 +90,15 @@ function CollectorAPI(agent) {
   }
 }
 
+CollectorAPI.prototype._throwCallbackError = function _throwCallbackError() {
+  throw new TypeError('callback is required')
+}
+
 /**
  * Updates all methods except preconnect w/ new host/port pairs sent down from server
  * during preconnect (via redirect_host). Preconnect does not update.
  *
- * @param endpoint
+ * @param {string} endpoint collector name
  */
 CollectorAPI.prototype._updateEndpoints = function _updateEndpoints(endpoint) {
   logger.trace('Updating endpoints to: ', endpoint)
@@ -107,112 +112,116 @@ CollectorAPI.prototype._updateEndpoints = function _updateEndpoints(endpoint) {
 
 CollectorAPI.prototype.connect = function connect(callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
 
   logger.trace('Starting collector.')
 
   this._agent.setState('connecting')
 
-  const api = this
-  const max = BACKOFFS.length
-  const errors = []
-  let attempts = 1
-
-  const metric = this._agent.metrics.getOrCreateMetric(
-    NAMES.SUPPORTABILITY.REGISTRATION + '/Attempts'
-  )
-
   // Reset headers map for good measure
   if (this._reqHeadersMap) {
     this._reqHeadersMap = null
   }
 
-  /**
-   * Checks if proxy is configured to connect via `proxy_host` and `proxy_port`
-   * and if error code is EPROTO or ECONNRESET. This is an indication their proxy
-   * server only accepts HTTP connections, and we should provide an actionable warning to
-   * fix the misconfiguration by setting `proxy` to a fully qualified URL
-   *
-   * @param {Error} error
-   * @returns {boolean}
-   */
-  function isProxyMisconfigured(error) {
-    const config = api._agent.config
-    return (
-      error &&
-      ['EPROTO', 'ECONNRESET'].includes(error.code) &&
-      config.proxy_host &&
-      config.proxy_port &&
-      !config.proxy
-    )
+  const ctx = {
+    callback,
+    max: BACKOFFS.length,
+    errors: [],
+    attempts: 1
   }
+  this._login(this._retry.bind(this, ctx))
+}
 
-  /**
-   * @param error
-   * @param response
-   */
-  function retry(error, response) {
-    metric.incrementCallCount()
+/**
+ * Checks if proxy is configured to connect via `proxy_host` and `proxy_port`
+ * and if error code is EPROTO or ECONNRESET. This is an indication their proxy
+ * server only accepts HTTP connections, and we should provide an actionable warning to
+ * fix the misconfiguration by setting `proxy` to a fully qualified URL
+ *
+ * @param {Error} error response error
+ * @returns {boolean} determines if proxy is properly configured
+ */
+CollectorAPI.prototype._isProxyMisconfigured = function _isProxyMisconfigured(error) {
+  const config = this._agent.config
+  return (
+    error &&
+    ['EPROTO', 'ECONNRESET'].includes(error.code) &&
+    config.proxy_host &&
+    config.proxy_port &&
+    !config.proxy
+  )
+}
 
-    if (error) {
-      errors.push(error)
-    } else if (response && SUCCESS.has(response.status)) {
-      dumpErrors(errors, 'connect')
-      return callback(null, CollectorResponse.success(response.payload))
-    }
-    if (!response) {
-      response = CollectorResponse.retry()
-    }
+/**
+ * @param {object} ctx context object to pass from parent and between recursions.
+ * @param {Error} error response error
+ * @param {http.ServerResponse} response response from collector
+ * @returns {void}
+ */
+CollectorAPI.prototype._retry = function _retry(ctx, error, response) {
+  const api = this
+  const metric = this._agent.metrics.getOrCreateMetric(
+    NAMES.SUPPORTABILITY.REGISTRATION + '/Attempts'
+  )
 
-    // Retry everything except for an explicit Disconnect response code.
-    if (response.status === 410 || response.agentRun === AGENT_RUN_BEHAVIOR.SHUTDOWN) {
-      logger.error('The New Relic collector rejected this agent.')
-      return callback(null, CollectorResponse.fatal(response.payload))
-    } else if (response.status === 401) {
-      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)',
-        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).'
-      )
-    }
+  metric.incrementCallCount()
 
-    const backoff = BACKOFFS[Math.min(attempts, max) - 1]
-    if (backoff.warn) {
-      logger.warn('No connection has been established to New Relic after %d attempts.', attempts)
-    }
+  if (error) {
+    ctx.errors.push(error)
+  } else if (response && SUCCESS.has(response.status)) {
+    dumpErrors(ctx.errors, 'connect')
+    ctx.callback(null, CollectorResponse.success(response.payload))
+    return
+  }
+  if (!response) {
+    response = CollectorResponse.retry()
+  }
 
-    logger.debug(
+  // Retry everything except for an explicit Disconnect response code.
+  if (response.status === 410 || response.agentRun === AGENT_RUN_BEHAVIOR.SHUTDOWN) {
+    logger.error('The New Relic collector rejected this agent.')
+    return ctx.callback(null, CollectorResponse.fatal(response.payload))
+  } else if (response.status === 401) {
+    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)',
+      response.status
+    )
+  } else if (this._isProxyMisconfigured(error)) {
+    logger.warn(
       error,
-      'Failed to connect to New Relic after attempt %d, waiting %ds to retry.',
-      attempts,
-      backoff.interval
+      '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).'
     )
+  }
 
-    ++attempts
-    const timeout = setTimeout(function again() {
-      api._login(retry)
-    }, backoff.interval * TO_MILLIS)
-    timeout.unref()
+  const backoff = BACKOFFS[Math.min(ctx.attempts, ctx.max) - 1]
+  if (backoff.warn) {
+    logger.warn('No connection has been established to New Relic after %d attempts.', ctx.attempts)
   }
 
-  this._login(retry)
+  logger.debug(
+    error,
+    'Failed to connect to New Relic after attempt %d, waiting %ds to retry.',
+    ctx.attempts,
+    backoff.interval
+  )
+
+  ++ctx.attempts
+  const timeout = setTimeout(function again() {
+    api._login(api._retry.bind(api, ctx))
+  }, backoff.interval * TO_MILLIS)
+  timeout.unref()
 }
 
 CollectorAPI.prototype._login = function _login(callback) {
   const methods = this._methods
   const agent = this._agent
-  const self = this
 
   const preconnectData = { high_security: agent.config.high_security }
   if (agent.config.security_policies_token) {
@@ -221,56 +230,73 @@ CollectorAPI.prototype._login = function _login(callback) {
 
   const payload = [preconnectData]
 
-  methods.preconnect.invoke(payload, onPreConnect)
+  methods.preconnect.invoke(payload, this._onPreConnect.bind(this, callback))
+}
 
-  /**
-   * @param error
-   * @param response
-   */
-  function onPreConnect(error, response) {
-    if (error || !SUCCESS.has(response.status)) {
-      return callback(error, response)
-    }
+/**
+ * @param {Function} callback function to run after processing response
+ * @param {Error} error response error
+ * @param {http.ServerResponse} response collector response from pre connect
+ * @returns {void}
+ */
+CollectorAPI.prototype._onPreConnect = function _onPreConnect(callback, error, response) {
+  const agent = this._agent
+  if (error || !SUCCESS.has(response.status)) {
+    callback(error, response)
+    return
+  }
 
-    const res = response.payload || Object.create(null)
-    if (!res.redirect_host) {
+  const res = response.payload || Object.create(null)
+  this._handlePreConnectResponse(res)
+
+  const policies = res.security_policies || Object.create(null)
+
+  const laspResponse = agent.config.applyLasp(agent, policies)
+  if (laspResponse.shouldShutdownRun()) {
+    callback(null, laspResponse)
+    return
+  }
+
+  this._getFacts(laspResponse.payload, callback)
+}
+
+/**
+ * Checks the redirect_host and determines based on the URL if the collector
+ * needs to update the endpoint with new endpoint
+ *
+ * @param {http.ServerResponse} res collector response
+ */
+CollectorAPI.prototype._handlePreConnectResponse = function _handlePreConnectResponse(res) {
+  const agent = this._agent
+
+  if (!res.redirect_host) {
+    logger.error(
+      "Requesting this account's collector from %s failed; trying default.",
+      agent.config.host
+    )
+  } else {
+    const parts = res.redirect_host.split(':')
+    if (parts.length > 2) {
       logger.error(
-        "Requesting this account's collector from %s failed; trying default.",
-        agent.config.host
+        "Requesting collector from %s returned bogus result '%s'; trying default.",
+        agent.config.host,
+        res.redirect_host
       )
     } else {
-      const parts = res.redirect_host.split(':')
-      if (parts.length > 2) {
-        logger.error(
-          "Requesting collector from %s returned bogus result '%s'; trying default.",
-          agent.config.host,
-          res.redirect_host
-        )
-      } else {
-        logger.debug(
-          "Requesting this account's collector from %s returned %s; reconfiguring.",
-          agent.config.host,
-          res.redirect_host
-        )
-
-        const [host, port] = parts
-        const newEndpoint = {
-          host: host,
-          port: port || DEFAULT_PORT
-        }
+      logger.debug(
+        "Requesting this account's collector from %s returned %s; reconfiguring.",
+        agent.config.host,
+        res.redirect_host
+      )
 
-        self._updateEndpoints(newEndpoint)
+      const [host, port] = parts
+      const newEndpoint = {
+        host: host,
+        port: port || DEFAULT_PORT
       }
-    }
 
-    const policies = res.security_policies || Object.create(null)
-
-    const laspResponse = agent.config.applyLasp(agent, policies)
-    if (laspResponse.shouldShutdownRun()) {
-      return callback(null, laspResponse)
+      this._updateEndpoints(newEndpoint)
     }
-
-    self._getFacts(laspResponse.payload, callback)
   }
 }
 
@@ -292,50 +318,56 @@ CollectorAPI.prototype._getFacts = function _getFacts(lasp, callback) {
 }
 
 CollectorAPI.prototype._connect = function _connect(env, callback) {
-  const collector = this
   const methods = this._methods
-  const agent = this._agent
+  methods.connect.invoke(env, this._onConnect.bind(this, callback))
+}
 
-  methods.connect.invoke(env, onConnect)
+/**
+ *
+ * Handles the response to the connect call
+ *
+ * @param {Function} callback function to run after processing response
+ * @param {Error} error collector response error
+ * @param {http.ServerOptions} res collector response
+ */
+CollectorAPI.prototype._onConnect = function _onConnect(callback, error, res) {
+  const agent = this._agent
+  const methods = this._methods
 
-  /**
-   * @param error
-   * @param res
-   */
-  function onConnect(error, res) {
-    if (error || !SUCCESS.has(res.status)) {
-      return callback(error, res)
-    }
+  if (error || !SUCCESS.has(res.status)) {
+    callback(error, res)
+    return
+  }
 
-    const config = res.payload
-    if (!config || !config.agent_run_id) {
-      return callback(new Error('No agent run ID received from handshake.'), res)
-    }
+  const config = res.payload
+  if (!config || !config.agent_run_id) {
+    callback(new Error('No agent run ID received from handshake.'), res)
+    return
+  }
 
-    agent.setState('connected')
+  agent.setState('connected')
 
-    logger.info(
-      'Connected to %s:%d with agent run ID %s.',
-      methods.connect.endpoint.host,
-      methods.connect.endpoint.port,
-      config.agent_run_id
-    )
+  logger.info(
+    'Connected to %s:%d with agent run ID %s.',
+    methods.connect.endpoint.host,
+    methods.connect.endpoint.port,
+    config.agent_run_id
+  )
 
-    // Log "Reporting to..." message from connect response.
-    if (config.messages) {
-      config.messages.forEach((element) => {
-        logger.info(element.message)
-      })
-    }
+  // Log "Reporting to..." message from connect response.
+  if (config.messages) {
+    config.messages.forEach((element) => {
+      logger.info(element.message)
+    })
+  }
 
-    // Store request headers for future collector requests if they're present
-    collector._reqHeadersMap = config.request_headers_map
+  // Store request headers for future collector requests if they're present
+  this._reqHeadersMap = config.request_headers_map
 
-    // pass configuration data from the API so automatic reconnect works
-    agent.reconfigure(config)
+  // pass configuration data from the API so automatic reconnect works
+  agent.reconfigure(config)
 
-    callback(null, res)
-  }
+  callback(null, res)
 }
 
 /**
@@ -373,13 +405,15 @@ CollectorAPI.prototype.reportSettings = function reportSettings(callback) {
  *
  * @param {Array}    errors   The encoded errors list.
  * @param {Function} callback The continuation / error handler.
+ * @returns {void}
  */
 CollectorAPI.prototype.error_data = function errorData(errors, callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
   if (!errors) {
-    return callback(new TypeError('must pass errors to send'))
+    callback(new TypeError('must pass errors to send'))
+    return
   }
 
   this._sendData(this._methods.errors, errors, callback)
@@ -387,26 +421,30 @@ CollectorAPI.prototype.error_data = function errorData(errors, callback) {
 
 CollectorAPI.prototype.error_event_data = function errorEvents(events, callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
   if (!events) {
-    return callback(new TypeError('must pass errors to send'))
+    callback(new TypeError('must pass errors to send'))
+    return
   }
 
   this._sendData(this._methods.errorEvents, events, callback)
 }
 
 CollectorAPI.prototype.analytic_event_data = transactionEvents
+
 /**
- * @param events
- * @param callback
+ * @param {Array} events list of events to send to collector
+ * @param {Function} callback handler on response
+ * @returns {void}
  */
 function transactionEvents(events, callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
   if (!events) {
-    return callback(new TypeError('must pass events to send'))
+    callback(new TypeError('must pass events to send'))
+    return
   }
 
   this._sendData(this._methods.events, events, callback)
@@ -414,10 +452,11 @@ function transactionEvents(events, callback) {
 
 CollectorAPI.prototype.custom_event_data = function customEvents(events, callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
   if (!events) {
-    return callback(new TypeError('must pass events to send'))
+    callback(new TypeError('must pass events to send'))
+    return
   }
 
   this._sendData(this._methods.customEvents, events, callback)
@@ -441,10 +480,11 @@ CollectorAPI.prototype.custom_event_data = function customEvents(events, callbac
  */
 CollectorAPI.prototype.metric_data = function metricData(metrics, callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
   if (!metrics) {
-    return callback(new TypeError('must pass metrics to send'))
+    callback(new TypeError('must pass metrics to send'))
+    return
   }
 
   this._sendData(this._methods.metrics, metrics, callback)
@@ -464,20 +504,22 @@ CollectorAPI.prototype.metric_data = function metricData(metrics, callback) {
  */
 CollectorAPI.prototype.sql_trace_data = function queryData(queries, callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
   if (!queries) {
-    return callback(new TypeError('must pass queries to send'))
+    callback(new TypeError('must pass queries to send'))
+    return
   }
   this._sendData(this._methods.queryData, queries, callback)
 }
 
 CollectorAPI.prototype.span_event_data = function spanEvents(events, callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
   if (!events) {
-    return callback(new TypeError('must pass spans to send'))
+    callback(new TypeError('must pass spans to send'))
+    return
   }
   this._sendData(this._methods.spanEvents, events, callback)
 }
@@ -497,16 +539,18 @@ CollectorAPI.prototype.span_event_data = function spanEvents(events, callback) {
  * @param {Function} callback The continuation / error handler.
  */
 CollectorAPI.prototype.transaction_sample_data = transactionSampleData
+
 /**
- * @param traces
- * @param callback
+ * @param {Array} traces list of traces to send
+ * @param {Function} callback handler on response
  */
 function transactionSampleData(traces, callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
   if (!traces) {
-    return callback(new TypeError('must pass traces to send'))
+    callback(new TypeError('must pass traces to send'))
+    return
   }
 
   this._sendData(this._methods.traces, traces, callback)
@@ -521,16 +565,16 @@ function transactionSampleData(traces, callback) {
  * 1. An array of logs.
  * 2. A list of common attributes(optional).
  *
- * @param {Array}    logsRecords   The encoded log entries.
- * @param logRecords
- * @param {Function} callback      The continuation / error handler.
+ * @param {Array} logRecords The encoded log entries.
+ * @param {Function} callback The continuation / error handler.
  */
 CollectorAPI.prototype.log_event_data = function logEventData(logRecords, callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
   if (!logRecords) {
-    return callback(new TypeError('must pass logRecords to send'))
+    callback(new TypeError('must pass logRecords to send'))
+    return
   }
 
   this._sendData(this._methods.logEvents, logRecords, callback)
@@ -540,12 +584,11 @@ CollectorAPI.prototype.log_event_data = function logEventData(logRecords, callba
  * Sends no data aside from the message itself. Clears the run ID, which
  * effectively disconnects the agent from the collector.
  *
- * @param Function callback Runs after the run ID has been cleared.
- * @param callback
+ * @param {Function} callback Runs after the run ID has been cleared.
  */
 CollectorAPI.prototype.shutdown = function shutdown(callback) {
   if (!callback) {
-    throw new TypeError('callback is required')
+    this._throwCallbackError()
   }
 
   logger.info('Shutting down collector.')
@@ -554,8 +597,8 @@ CollectorAPI.prototype.shutdown = function shutdown(callback) {
   this._methods.shutdown.invoke(null, this._reqHeadersMap, onShutdown)
 
   /**
-   * @param error
-   * @param response
+   * @param {Error} error response error
+   * @param {http.ServerResponse} response response from collector
    */
   function onShutdown(error, response) {
     if (error) {
@@ -593,7 +636,8 @@ CollectorAPI.prototype._runLifecycle = function _runLifecycle(method, body, call
   const api = this
   method.invoke(body, this._reqHeadersMap, function standardHandler(error, response) {
     if (error) {
-      return callback(error)
+      callback(error)
+      return
     }
 
     return api._handleResponseCode(response, method.name, callback)
@@ -620,6 +664,7 @@ CollectorAPI.prototype._sendData = function _sendData(method, data, callback) {
 
     // TODO: log the payload if exists?
 
+    /*
     if (response.agentRun === AGENT_RUN_BEHAVIOR.SHUTDOWN) {
       // TODO: for now, shut handled in _handleResponseCode for consistency
       // either find way to safely change while side-by-side or move
@@ -635,7 +680,8 @@ CollectorAPI.prototype._sendData = function _sendData(method, data, callback) {
       // })
 
       callback(null, { retainData: response.retainData })
-    } else if (response.agentRun === AGENT_RUN_BEHAVIOR.RESTART) {
+      */
+    if (response.agentRun === AGENT_RUN_BEHAVIOR.RESTART) {
       // TODO: almost seems better to leg aggregator finish (cb) then restart?
 
       // TODO: ensure harvesting stopped for all other endpoints. same for shutdown.
@@ -666,60 +712,55 @@ CollectorAPI.prototype.isConnected = function isConnected() {
   return !!this._agent.config.run_id
 }
 
+CollectorAPI.prototype._handleResponseCode = _handleResponseCode
+
 /**
  * Returns appropriate CollectorResponse object according to response code.
  *
- * @param {object} response
+ * @param {http.ServerResponse} response response from collector
  * @param {number} response.status  - Status code from collector response
  * @param {object} response.payload - Parsed response body, if any
  * @param {string} endpoint         - Collector endpoint name
  * @param {Function} cb             - CollectorAPI method invocation callback
  */
-CollectorAPI.prototype._handleResponseCode = _handleResponseCode
-/**
- * @param response
- * @param endpoint
- * @param cb
- */
 function _handleResponseCode(response, endpoint, cb) {
   const code = response.status
 
   /* eslint-disable padded-blocks */
   if (SUCCESS.has(code)) {
     // The request was a success!
-    return setImmediate(cb, null, CollectorResponse.success(response.payload))
+    setImmediate(cb, null, CollectorResponse.success(response.payload))
   } else if (RESTART.has(code)) {
     // The agent needs to disconnect and restart.
     logFailure(endpoint, code, 'Restarting')
-    return setImmediate(cb, null, CollectorResponse.reconnect(0, null))
+    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))
+    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))
+    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')
 
-    return this._agent.stop(function onShutdown() {
+    this._agent.stop(function onShutdown() {
       cb(null, CollectorResponse.fatal(response.payload))
     })
+  } else {
+    // 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)
+    setImmediate(cb, null, CollectorResponse.discard(null))
   }
-  /* eslint-enable padded-blocks */
-
-  // 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)
-  return setImmediate(cb, null, CollectorResponse.discard(null))
 }
 
 /**
- * @param endpoint
- * @param code
- * @param action
+ * @param {string} endpoint called endpoint
+ * @param {string} code http status code
+ * @param {string} action describes collector action
  */
 function logFailure(endpoint, code, action) {
   logger.error('Agent endpoint %s returned %s status. %s.', endpoint, code, action)