newrelic 5.10.0 → 5.11.0

package/NEWS.md

@@ -1,3 +1,31 @@
+### 5.11.0 (2019-07-29):
+
+* Implements Expected and Ignored Errors functionality
+
+* Bumps jsdoc and lodash dev dependency to avoid upstream vulnerability warning.
+
+* Added support for scoped package name introduced in hapi v18 (@hapi/hapi).
+
+  This will provide functionality at parity with instrumentation for hapi v17. Any
+  new features may not yet be supported.
+
+ Huge shoutout to Aori Nevo (@aorinevo) for this contribution.
+
+* Fixed bug where agent would count errors towards error metrics even if they were
+  dropped due to the error collector being disabled.
+
+* The agent will now properly track cached paths to files in loaded modules on Node
+  versions >10.
+
+  As of Node v11, the path to a file in a module being loaded will only be resolved
+  on the first load; subsequent resolution of that file will use a cached value.
+  The agent records this resolved path and uses it for relative file look ups in
+  order to deep link into modules using `Shim#require`. Since the agent couldn't
+  reliably get at the path on the subsequent calls to require, it now replicates
+  the caching logic and hold onto the resolved path for a given file.
+
+* Adds detailed logging through harvest/collector code to increase supportability.
+
 ### 5.10.0 (2019-06-11):
 
 * The agent now allows installation on node v11 and v12.

package/lib/agent.js

@@ -218,6 +218,7 @@ Agent.prototype.stop = function stop(callback) {
   const agent = this
 
   this.setState('stopping')
+
   this._stopHarvester()
   sampler.stop()
 
@@ -234,6 +235,8 @@ Agent.prototype.stop = function stop(callback) {
       callback(error)
     })
   } else {
+    logger.trace('Collector was not connected, invoking callback.')
+
     process.nextTick(callback)
   }
 }
@@ -331,6 +334,8 @@ Agent.prototype.reset = function reset() {
  * struggling.
  */
 Agent.prototype.harvest = function harvest(callback) {
+  logger.trace('Peparing to harvest.')
+
   if (!callback) {
     throw new TypeError('callback required!')
   }
@@ -338,7 +343,10 @@ Agent.prototype.harvest = function harvest(callback) {
   // 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!'))
     })
@@ -346,6 +354,8 @@ Agent.prototype.harvest = function harvest(callback) {
 
   // 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)
 
@@ -355,30 +365,40 @@ Agent.prototype.harvest = function harvest(callback) {
   // 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)
     }
@@ -391,16 +411,20 @@ Agent.prototype.harvest = function harvest(callback) {
  * NOTE: this doesn't currently work outside of serverless mode.
  */
 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('Not connected to New Relic!')
+    throw new Error('Sync harvest not connected/enabled!')
   }
 
   // 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)
 
@@ -414,7 +438,9 @@ Agent.prototype.harvestSync = function harvestSync() {
   const payloads = this._lastHarvest.getPayloads()
   collector.populateDataSync(payloads)
   collector.flushPayloadSync()
+
   agent.emit('harvestFinished')
+  logger.info('Harvest finished.')
 }
 
 Agent.prototype._generateHarvestMetrics = function _generateHarvestMetrics() {
@@ -489,7 +515,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)
 }
@@ -541,6 +567,8 @@ function _harvesterIntervalChange(interval, callback) {
  * @param {number} harvestSeconds How many seconds between harvests.
  */
 Agent.prototype._restartHarvester = function _restartHarvester(harvestSeconds) {
+  logger.trace('Restarting harvester.')
+
   this._stopHarvester()
   this._scheduleHarvester(harvestSeconds)
 }
@@ -549,6 +577,8 @@ Agent.prototype._restartHarvester = function _restartHarvester(harvestSeconds) {
  * Safely stop the harvest cycle timer.
  */
 Agent.prototype._stopHarvester = function _stopHarvester() {
+  logger.trace('Stopping harvester.')
+
   if (this.harvesterHandle) {
     clearTimeout(this.harvesterHandle)
   }
@@ -569,11 +599,17 @@ Agent.prototype._scheduleHarvester = function _scheduleHarvester(harvestSeconds)
 
   // 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 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.
@@ -583,6 +619,7 @@ Agent.prototype._scheduleHarvester = function _scheduleHarvester(harvestSeconds)
       }
     })
   }, harvestDelay)
+
   this.harvesterHandle.unref()
 }
 
@@ -735,7 +772,13 @@ Agent.prototype._transactionFinished = function _transactionFinished(transaction
       logger.debug('Explicitly not ignoring %s (%s).', transaction.name, transaction.id)
     }
     this.metrics.merge(transaction.metrics)
-    this.errors.onTransactionFinished(transaction, this.metrics)
+    let collectedErrors = this.errors.onTransactionFinished(transaction)
+
+    // the metric should be incremented only if the error was actually collected
+    if (collectedErrors > 0) {
+      this.metrics.getOrCreateMetric(NAMES.ERRORS.PREFIX + transaction.getFullName())
+        .incrementCallCount(collectedErrors)
+    }
     this.traces.add(transaction)
 
     const trace = transaction.trace

package/lib/collector/api.js

@@ -73,6 +73,8 @@ CollectorAPI.prototype.connect = function connect(callback) {
     throw new TypeError('callback is required')
   }
 
+  logger.trace('Starting collector.')
+
   this._agent.setState('connecting')
 
   const api = this
@@ -422,6 +424,8 @@ CollectorAPI.prototype.shutdown = function shutdown(callback) {
     throw new TypeError('callback is required')
   }
 
+  logger.info('Shutting down collector.')
+
   var agent = this._agent
   this._methods.shutdown.invoke(null, this._reqHeadersMap, onShutdown)
 
@@ -442,6 +446,8 @@ CollectorAPI.prototype.shutdown = function shutdown(callback) {
 }
 
 CollectorAPI.prototype.restart = function restart(callback) {
+  logger.info('Restarting collector.')
+
   var api = this
   this.shutdown(function reconnect() {
     api.connect(callback)

package/lib/collector/serverless.js

@@ -64,6 +64,8 @@ class ServerlessCollector {
    * @param {Function} cb The callback to invoke upon disabling the collector.
    */
   shutdown(cb) {
+    logger.trace('Disabling serverless collector.')
+
     this.enabled = false
     setImmediate(cb, null, CollectorResponse.success(null))
   }

package/lib/config/default.js

@@ -298,7 +298,13 @@ exports.config = () => ({
      * your own server's sake. The payload of events is compressed, but if it
      * grows too large the New Relic servers may reject it.
      */
-    max_event_samples_stored: 100
+    max_event_samples_stored: 100,
+
+    expected_classes: [],
+    expected_messages: {},
+    expected_status_codes: [],
+    ignore_classes:[],
+    ignore_messages:{}
   },
   /**
    * Error message redaction

package/lib/config/env.js

@@ -36,7 +36,10 @@ const ENV_MAPPING = {
       enabled: 'NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_ENABLED'
     },
     enabled: 'NEW_RELIC_ERROR_COLLECTOR_ENABLED',
-    ignore_status_codes: 'NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERROR_CODES'
+    ignore_status_codes: 'NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERROR_CODES',
+    ignore_classes: 'NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERRORS',
+    expected_status_codes: 'NEW_RELIC_ERROR_COLLECTOR_EXPECTED_ERROR_CODES',
+    expected_classes: 'NEW_RELIC_ERROR_COLLECTOR_EXPECTED_ERRORS',
   },
   strip_exception_messages: {
     enabled: 'NEW_RELIC_STRIP_EXCEPTION_MESSAGES_ENABLED'
@@ -147,6 +150,9 @@ const LIST_VARS = new Set([
   'NEW_RELIC_ATTRIBUTES_EXCLUDE',
   'NEW_RELIC_ATTRIBUTES_INCLUDE',
   'NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERROR_CODES',
+  'NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERRORS',
+  'NEW_RELIC_ERROR_COLLECTOR_EXPECTED_ERROR_CODES',
+  'NEW_RELIC_ERROR_COLLECTOR_EXPECTED_ERRORS',
   'NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_EXCLUDE',
   'NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_INCLUDE',
   'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_EXCLUDE',

package/lib/config/index.js

@@ -2,6 +2,7 @@
 
 const AttributeFilter = require('./attribute-filter')
 const CollectorResponse = require('../collector/response')
+const MergeServerConfig = require('./merge-server-config')
 const copy = require('../util/copy')
 const defaultConfig = require('./default').config
 const EventEmitter = require('events').EventEmitter
@@ -31,9 +32,11 @@ const CONFIG_FILE_LOCATIONS = [
   path.join(__dirname, '../../../..') // above node_modules
 ]
 
-const HAS_ARBITRARY_KEYS = [
+const HAS_ARBITRARY_KEYS = new Set([
+  'ignore_messages',
+  'expected_messages',
   'labels'
-]
+])
 
 const LASP_MAP = require('./lasp').LASP_MAP
 const ENV = require('./env')
@@ -72,7 +75,7 @@ function fromObjectList(setting) {
   try {
     return JSON.parse('[' + setting + ']')
   } catch (error) {
-    logger.error("New Relic configurator could not deserialize object list:")
+    logger.error('New Relic configurator could not deserialize object list:')
     logger.error(error.stack)
   }
 }
@@ -96,6 +99,8 @@ function _findConfigFile() {
 function Config(config) {
   EventEmitter.call(this)
 
+  // helper object for merging server side values
+  this.mergeServerConfig = new MergeServerConfig(this)
   // 1. start by cloning the defaults
   try {
     Object.assign(this, defaultConfig())
@@ -151,7 +156,7 @@ function Config(config) {
   this.browser_monitoring.loader_version = ''
 
   // Settings to play nice with DLPs (see NODE-1044).
-  this.compressed_content_encoding = "deflate"  // Deflate or gzip
+  this.compressed_content_encoding = 'deflate'  // Deflate or gzip
   this.simple_compression = false               // Disables subcomponent compression
   this.put_for_data_send = false                // Changes http verb for harvest
 
@@ -178,10 +183,10 @@ function Config(config) {
   if (this.high_security) {
     if (this.security_policies_token) {
       throw new Error(
-        "Security Policies and High Security Mode cannot both be present " +
-        "in the agent configuration. If Security Policies have been set " +
-        "for your account, please ensure the security_policies_token is " +
-        "set but high_security is disabled (default)."
+        'Security Policies and High Security Mode cannot both be present ' +
+        'in the agent configuration. If Security Policies have been set ' +
+        'for your account, please ensure the security_policies_token is ' +
+        'set but high_security is disabled (default).'
       )
     }
     this._applyHighSecurity()
@@ -398,7 +403,7 @@ Config.prototype._fromServer = function _fromServer(params, key) {
       )
       break
     case 'error_collector.ignore_status_codes':
-      this._updateNestedIfChanged(
+      this._validateThenUpdateStatusCodes(
         params,
         this.error_collector,
         'error_collector.ignore_status_codes',
@@ -406,6 +411,47 @@ Config.prototype._fromServer = function _fromServer(params, key) {
       )
       this._canonicalize()
       break
+    case 'error_collector.expected_status_codes':
+      this._validateThenUpdateStatusCodes(
+        params,
+        this.error_collector,
+        'error_collector.expected_status_codes',
+        'expected_status_codes'
+      )
+      this._canonicalize()
+      break
+    case 'error_collector.ignore_classes':
+      this._validateThenUpdateErrorClasses(
+        params,
+        this.error_collector,
+        'error_collector.ignore_classes',
+        'ignore_classes'
+      )
+      break
+    case 'error_collector.expected_classes':
+      this._validateThenUpdateErrorClasses(
+        params,
+        this.error_collector,
+        'error_collector.expected_classes',
+        'expected_classes'
+      )
+      break
+    case 'error_collector.ignore_messages':
+      this._validateThenUpdateErrorMessages(
+        params,
+        this.error_collector,
+        'error_collector.ignore_messages',
+        'ignore_messages'
+      )
+      break
+    case 'error_collector.expected_messages':
+      this._validateThenUpdateErrorMessages(
+        params,
+        this.error_collector,
+        'error_collector.expected_messages',
+        'expected_messages'
+      )
+      break
     case 'error_collector.capture_events':
       this._updateNestedIfChanged(
         params,
@@ -550,6 +596,153 @@ Config.prototype._updateIfChanged = function _updateIfChanged(json, key) {
   this._updateNestedIfChanged(json, this, key, key)
 }
 
+/**
+ * Expected and Ignored status code configuration values should look like this
+ *
+ *     [500,'501','503-507']
+ *
+ * If the server side config is not in this format, it might put the agent
+ * in a world of hurt.  So, before we pass everything on to
+ * _updateNestedIfChanged, we'll do some validation.
+ *
+ * @param {object} remote    JSON sent from New Relic.
+ * @param {object} local     A portion of this configuration object.
+ * @param {string} remoteKey The name sent by New Relic.
+ * @param {string} localKey  The local name.
+ */
+Config.prototype._validateThenUpdateStatusCodes = _validateThenUpdateStatusCodes
+function _validateThenUpdateStatusCodes(remote, local, remoteKey, localKey) {
+  let valueToTest = remote[remoteKey]
+  if (!Array.isArray(valueToTest)) {
+    logger.warn(
+      'Saw SSC (ignore|expect)_status_codes that is not an array, will not merge: %s',
+      valueToTest
+    )
+    return
+  }
+
+  let valid = true
+  valueToTest.forEach(function validateArray(thingToTest) {
+    if (!('string' === (typeof thingToTest) || 'number' === (typeof thingToTest))) {
+      logger.warn(
+        'Saw SSC (ignore|expect)_status_code that is not a number or string,' +
+        'will not merge: %s', thingToTest
+      )
+      valid = false
+    }
+  })
+  if (!valid) {
+    return
+  }
+
+  return this._updateNestedIfChanged(remote, local, remoteKey, localKey)
+}
+
+/**
+ * Expected and Ignored classes configuration values should look like this
+ *
+ *     ['Error','Again']
+ *
+ * If the server side config is not in this format, it might put the agent
+ * in a world of hurt.  So, before we pass everything on to
+ * _updateNestedIfChanged, we'll do some validation.
+ *
+ * @param {object} remote    JSON sent from New Relic.
+ * @param {object} local     A portion of this configuration object.
+ * @param {string} remoteKey The name sent by New Relic.
+ * @param {string} localKey  The local name.
+ */
+Config.prototype._validateThenUpdateErrorClasses = _validateThenUpdateErrorClasses
+
+function _validateThenUpdateErrorClasses(remote, local, remoteKey, localKey) {
+  let valueToTest = remote[remoteKey]
+  if (!Array.isArray(valueToTest)) {
+    logger.warn(
+      'Saw SSC (ignore|expect)_classes that is not an array, will not merge: %s',
+      valueToTest
+    )
+    return
+  }
+
+  let valid = true
+  Object.keys(valueToTest).forEach(function validateArray(key) {
+    let thingToTest = valueToTest[key]
+    if ('string' !== (typeof thingToTest)) {
+      logger.warn(
+        'Saw SSC (ignore|expect)_class that is not a string, will not merge: %s',
+        thingToTest
+      )
+      valid = false
+    }
+  })
+  if (!valid) {
+    return
+  }
+
+  return this._updateNestedIfChanged(remote, local, remoteKey, localKey)
+}
+
+/**
+ * Expected and Ignore messages configuration values should look like this
+ *
+ *     {'ErrorType':['Error Message']}
+ *
+ * If the server side config is not in this format, it might put the agent
+ * in a world of hurt.  So, before we pass everything on to
+ * _updateNestedIfChanged, we'll do some validation.
+ *
+ * @param {object} remote    JSON sent from New Relic.
+ * @param {object} local     A portion of this configuration object.
+ * @param {string} remoteKey The name sent by New Relic.
+ * @param {string} localKey  The local name.
+ */
+Config.prototype._validateThenUpdateErrorMessages = _validateThenUpdateErrorMessages
+
+function _validateThenUpdateErrorMessages(remote, local, remoteKey, localKey) {
+  let valueToTest = remote[remoteKey]
+  if (Array.isArray(valueToTest)) {
+    logger.warn(
+      'Saw SSC (ignore|expect)_message that is an Array, will not merge: %s',
+      valueToTest
+    )
+    return
+  }
+
+  if (!valueToTest) {
+    logger.warn('SSC ignore|expect_message is null or undefined, will not merge')
+    return
+  }
+
+  if ('object' !== typeof valueToTest) {
+    logger.warn(
+      'Saw SSC (ignore|expect)_message that is primitive/scaler, will not merge: %s',
+      valueToTest
+    )
+    return
+  }
+
+  if (!valueToTest) {
+    logger.warn('SSC ignore|expect_message is null or undefined, will not merge')
+    return
+  }
+
+  let valid = true
+  Object.keys(valueToTest).forEach(function validateArray(key) {
+    let arrayToTest = valueToTest[key]
+    if (!Array.isArray(arrayToTest)) {
+      logger.warn(
+        'Saw SSC message array that is not an array, will not merge: %s',
+        arrayToTest
+      )
+      valid = false
+    }
+  })
+  if (!valid) {
+    return
+  }
+
+  return this._updateNestedIfChanged(remote, local, remoteKey, localKey)
+}
 /**
  * Some parameter values are nested, need a simple way to change them as well.
  * Will merge local and remote if and only if both are arrays.
@@ -572,18 +765,13 @@ function _updateNestedIfChanged(remote, local, remoteKey, localKey) {
 Config.prototype._updateNestedIfChangedRaw = _updateNestedIfChangedRaw
 
 function _updateNestedIfChangedRaw(remote, local, remoteKey, localKey) {
-  var value = remote[remoteKey]
-  if (value != null && local[localKey] !== value) {
-    if (Array.isArray(value) && Array.isArray(local[localKey])) {
-      value.forEach(function pushIfNew(element) {
-        if (local[localKey].indexOf(element) === -1) local[localKey].push(element)
-      })
-    } else {
-      local[localKey] = value
-    }
-    this.emit(remoteKey, value)
-    logger.debug('Configuration of %s was changed to %s by New Relic.', remoteKey, value)
-  }
+  return this.mergeServerConfig.updateNestedIfChanged(
+    remote,
+    local,
+    remoteKey,
+    localKey,
+    logger
+  )
 }
 
 /**
@@ -645,7 +833,7 @@ Config.prototype.logUnsupported = function logUnsupported(json, key) {
 Config.prototype.logUnknown = function logUnknown(json, key) {
   var value = json[key]
   logger.debug(
-    "New Relic sent unknown configuration parameter %s with value %s.",
+    'New Relic sent unknown configuration parameter %s with value %s.',
     key,
     value
   )
@@ -813,8 +1001,8 @@ Config.prototype._fromPassed = function _fromPassed(external, internal, arbitrar
 
     if (typeof node === 'object' && !Array.isArray(node)) {
       // is top level and can have arbitrary keys
-      var isTop = internal === this && HAS_ARBITRARY_KEYS.indexOf(key) !== -1
-      this._fromPassed(node, internal[key], isTop)
+      var allowArbitrary = internal === this || HAS_ARBITRARY_KEYS.has(key)
+      this._fromPassed(node, internal[key], allowArbitrary)
     } else {
       internal[key] = node
     }
@@ -994,6 +1182,11 @@ Config.prototype._canonicalize = function _canonicalize() {
     this.error_collector.ignore_status_codes = _parseCodes(statusCodes)
   }
 
+  const expectedCodes = this.error_collector && this.error_collector.expected_status_codes
+  if (statusCodes) {
+    this.error_collector.expected_status_codes = _parseCodes(expectedCodes)
+  }
+
   var logAliases = {
     verbose: 'trace',
     debugging: 'debug',
@@ -1327,7 +1520,7 @@ function initialize(config) {
 
   config = new Config(userConf)
   config.config_file_path = filepath
-  logger.debug("Using configuration file %s.", filepath)
+  logger.debug('Using configuration file %s.', filepath)
 
   config.validateFlags()
 

package/lib/config/merge-server-config.js

@@ -0,0 +1,56 @@
+'use strict'
+class MergeServerConfig {
+  constructor(config) {
+    this.config = config
+  }
+
+  updateNestedIfChanged(remote, local, remoteKey, localKey, logger) {
+    var value = remote[remoteKey]
+
+    // if the value hasn't changed, skip this work
+    if (value === null || local[localKey] === value) {
+      return
+    }
+
+    // we need different update/merge logic if the server
+    // value is an array, a simple object, or anything else
+    if (Array.isArray(value) && Array.isArray(local[localKey])) {
+      this.updateArray(value, local, localKey)
+    } else if (this.isSimpleObject(value) && this.isSimpleObject(local[localKey])) {
+      this.updateObject(value, local, localKey)
+    } else {
+      local[localKey] = value
+    }
+    this.config.emit(remoteKey, value)
+    logger.debug('Configuration of %s was changed to %s by New Relic.', remoteKey, value)
+  }
+
+  updateArray(value, local, localKey) {
+    value.forEach( (element) => {
+      if (local[localKey].indexOf(element) === -1) local[localKey].push(element)
+    })
+  }
+
+  updateObject(value, local, localKey) {
+    // go through each key of the object and update it
+    Object.keys(value).forEach( (element) => {
+      if (Array.isArray(local[localKey][element]) && Array.isArray(value[element])) {
+        // if both key-values are arrays, push the remote value onto the local array
+        value[element].forEach( (elementValue) => {
+          if (-1 === local[localKey][element].indexOf(elementValue)) {
+            local[localKey][element].push(elementValue)
+          }
+        })
+      } else {
+        // otherwise, replace the local value with the server value
+        local[localKey][element] = value[element]
+      }
+    })
+  }
+
+  isSimpleObject(thing) {
+    return 'object' === (typeof thing) && this !== null
+  }
+}
+
+module.exports = MergeServerConfig