newrelic 5.13.0 → 5.13.1

package/lib/collector/api.js

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

package/lib/config/default.js

@@ -179,6 +179,13 @@ exports.config = () => ({
     filter_cache_limit: 1000
   },
 
+  diagnostics: {
+    code_injector: {
+      enabled: false,
+      internal_file_pattern: /nodejs_agent\/(?:(?!test))|\/node_modules\/(?:@)?newrelic/
+    }
+  },
+
   logging: {
     /**
      * Verbosity of the module's logging. This module uses bunyan

package/lib/config/env.js

@@ -51,6 +51,11 @@ const ENV_MAPPING = {
       include: 'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_INCLUDE'
     }
   },
+  diagnostics: {
+    code_injector: {
+      enabled: 'NEW_RELIC_DIAGNOSTICS_CODE_INJECTOR_ENABLED'
+    }
+  },
   transaction_tracer: {
     attributes: {
       enabled: 'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_ENABLED',
@@ -186,6 +191,7 @@ const BOOLEAN_VARS = new Set([
   'NEW_RELIC_TRACER_ENABLED',
   'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_ENABLED',
   'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_ENABLED',
+  'NEW_RELIC_DIAGNOSTICS_CODE_INJECTOR_ENABLED',
   'NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_ENABLED',
   'NEW_RELIC_DEBUG_METRICS',
   'NEW_RELIC_DEBUG_TRACER',

package/lib/config/index.js

@@ -135,9 +135,6 @@ function Config(config) {
   this.sampling_target_period_in_seconds = 60
   this.max_payload_size_in_bytes = DEFAULT_MAX_PAYLOAD_SIZE_IN_BYTES
 
-  // how frequently harvester runs
-  this.data_report_period = 60
-
   // this value is arbitrary
   this.max_trace_segments = 900
 
@@ -338,7 +335,6 @@ Config.prototype._fromServer = function _fromServer(params, key) {
 
     case 'apdex_t':
     case 'web_transactions_apdex':
-    case 'data_report_period':
       this._updateIfChanged(params, key)
       break
     case 'event_harvest_config':
@@ -1029,7 +1025,7 @@ Config.prototype._fromPassed = function _fromPassed(external, internal, arbitrar
       return
     }
 
-    if (typeof node === 'object' && !Array.isArray(node)) {
+    if (typeof node === 'object' && !(node instanceof RegExp) && !Array.isArray(node)) {
       // is top level and can have arbitrary keys
       var allowArbitrary = internal === this || HAS_ARBITRARY_KEYS.has(key)
       this._fromPassed(node, internal[key], allowArbitrary)
@@ -1207,6 +1203,10 @@ Config.prototype._enforceServerless = function _enforceServerless(inputConfig) {
     }
     // default trusted_account_key to account_id
     this.trusted_account_key = this.trusted_account_key || this.account_id
+
+    // Not required in serverless mode but must default to Unknown to function.
+    this.primary_application_id = this.primary_application_id || 'Unknown'
+
     return
   }
   const DT_KEYS = ['account_id', 'primary_application_id', 'trusted_account_key']

package/lib/injector.js

@@ -0,0 +1,161 @@
+'use strict'
+
+// to avoid parsing the esprima code base we require it here
+// TODO: excise this with better internal file filtering
+const esprima = require('esprima')
+const ecg = require('escodegen')
+const fileNameToken = {
+  type: 'Literal',
+  value: null
+}
+const lineNumberTokenTemplate = {
+  type: 'Literal',
+  value: null
+}
+
+class Mutator {
+  constructor(appliesTo, mutate) {
+    this.appliesTo = appliesTo
+    this.mutate = mutate
+    this.tokens = []
+  }
+
+  add(token) {
+    this.tokens.push(token)
+  }
+
+  apply() {
+    this.tokens.forEach(this.mutate)
+  }
+}
+
+const functionTypes = new Set([
+  'ArrowFunctionExpression',
+  'FunctionExpression',
+  'AsyncFunction'
+])
+
+const equalityCheckOps = new Set([
+  '==',
+  '===',
+  '!=',
+  '!==',
+  'instanceof'
+])
+
+const variableTypes = new Set([
+  'MemberExpression',
+  'Identifier'
+])
+
+const callTypes = new Set([
+  'CallExpression',
+  'NewExpression'
+])
+
+const wrapTemplate = esprima.parse('__NR_wrap()').body[0].expression
+const unwrapTemplate = esprima.parse('__NR_unwrap()').body[0].expression
+
+const mutators = [
+  new Mutator(function wrapAssignmentPredicate(token) {
+    return token.type === 'AssignmentExpression' &&
+      token.operator === '=' &&
+      functionTypes.has(token.right.type)
+  }, function injectWrapAssignment(token) {
+    token.right = wrapToken(token.right)
+  }),
+  new Mutator(function wrapArgPredicate(token) {
+    return callTypes.has(token.type)
+  }, function injectWrapArg(token) {
+    token.arguments = token.arguments.map(wrapToken)
+  }),
+  new Mutator(function unwrapPredicate(token) {
+    return token.type === 'BinaryExpression' && equalityCheckOps.has(token.operator)
+  }, function injectUnwrap(token) {
+    token.left = unwrapToken(token.left)
+    token.right = unwrapToken(token.right)
+  })
+]
+
+function wrapToken(argToken) {
+  const type = argToken.type
+  if (
+    !functionTypes.has(type) &&
+    !callTypes.has(type) &&
+    !variableTypes.has(type) ||
+    !argToken.loc
+  ) {
+    return argToken
+  }
+
+  const wrapped = Object.assign({}, wrapTemplate)
+  const lineNumberToken = Object.assign({}, lineNumberTokenTemplate)
+  lineNumberToken.value = argToken.loc.start.line
+  wrapped.arguments = [argToken, lineNumberToken, Object.assign({}, fileNameToken)]
+  return wrapped
+}
+
+function unwrapToken(argToken) {
+  if (!variableTypes.has(argToken.type)) {
+    return argToken
+  }
+
+  const wrapped = Object.assign({}, unwrapTemplate)
+  wrapped.arguments = [argToken]
+  return wrapped
+}
+
+function inject(sourceCode, file) {
+  // wrap the incoming file code to make it more palatable for esprima.
+  // node likewise wraps the contents of the file in a function, so this
+  // replicates the behavior (e.g. allows for global returns)
+  sourceCode = 'function main() {' + sourceCode + '}'
+  const sourceRootBody = esprima.parse(sourceCode, {loc: true}).body[0].body.body
+
+  const toRelax = [].concat(sourceRootBody)
+
+  while (toRelax.length) {
+    const currentToken = toRelax.pop()
+
+    mutators.forEach(m => {
+      if (m.appliesTo(currentToken)) {
+        m.add(currentToken)
+      }
+    })
+
+    for (let key of Object.keys(currentToken)) {
+      if (key === 'loc') continue
+      const value = currentToken[key]
+      if (value && value instanceof Object) {
+        if (Array.isArray(value)) {
+          for (let t of value) {
+            if (t) {
+              toRelax.push(t)
+            }
+          }
+        } else {
+          toRelax.push(value)
+        }
+      }
+    }
+  }
+
+  // TODO: make this less janky
+  fileNameToken.value = file
+  mutators.forEach(m => m.apply())
+  fileNameToken.value = null
+  // create a new base level token that contains all the statements we
+  // want to pass back to node
+  const printed = ecg.generate({
+    type: 'Program',
+    body: sourceRootBody,
+    sourceType: 'script'
+  }, {
+    format: {
+      semicolons: false
+    }
+  })
+  return printed
+}
+
+module.exports = { inject }

package/lib/shimmer.js

@@ -6,6 +6,7 @@ var logger = require('./logger').child({component: 'shimmer'})
 var INSTRUMENTATIONS = require('./instrumentations')()
 var properties = require('./util/properties')
 var shims = require('./shim')
+const { inject } = require('./injector')
 
 var MODULE_TYPE = shims.constants.MODULE_TYPE
 
@@ -342,6 +343,121 @@ var shimmer = module.exports = {
     var Module = require('module')
     var filepathMap = {}
 
+    // TODO: how do we unpatch this?
+    const diagConf = agent.config.diagnostics.code_injector
+    if (diagConf.enabled) {
+      // XXX: this is required to handle unwrapping event listener removal
+      const EEProto = require('events').EventEmitter.prototype
+      shimmer.wrapMethod(
+        EEProto,
+        'EventEmitter.prototype',
+        ['addListener', 'on', 'once', 'off', 'prependListener', 'prependOnceListener'],
+        function wrapAddListener(addListener) {
+          return function wrappedAddListener(ev, listener) {
+            return addListener.call(this, ev, __NR_unwrap(listener))
+          }
+        }
+      )
+      shimmer.wrapMethod(
+        EEProto,
+        'EventEmitter.prototype',
+        'removeListener',
+        function wrapRemoveListener(removeListener) {
+          return function wrappedRemoveListener(ev, listener) {
+            return removeListener.call(this, ev, __NR_unwrap(listener))
+          }
+        }
+      )
+      const internalCodePattern = diagConf.internal_file_pattern
+      const proto = Module.prototype
+      shimmer.wrapMethod(
+        proto,
+        'Module.prototype',
+        '_compile',
+        function wrapCompile(_compile) {
+          return function wrappedCompile(code, file) {
+            let injected
+            try {
+              injected = internalCodePattern.test(file) ? code : inject(code, file)
+              return _compile.call(this, injected, file)
+            } catch (e) {
+              logger.debug('Unable to parse file:', file, e)
+              return _compile.call(this, code, file)
+            }
+          }
+        }
+      )
+
+      // TODO: use shimmer methods
+      global.tracer = agent.tracer
+      global.__NR_wrap = __NR_wrap
+      function __NR_wrap(f, lineNum, fileName) {
+        const scheduledSegment = agent.tracer.getSegment()
+        if (
+          typeof f !== 'function' ||
+          !scheduledSegment ||
+          !scheduledSegment.transaction.isActive()
+        ) {
+          return f
+        }
+
+
+        const scheduledTransaction = scheduledSegment.transaction
+        return new Proxy(f, {
+          get: function getTrap(target, prop) {
+            // Allow for look up of the target
+            if (prop === '__NR_new_original') {
+              return target
+            }
+            return target[prop]
+          },
+          construct: function constructTrap(Target, proxyArgs) {
+            const currentSegment = agent.tracer.getSegment()
+            if (
+              scheduledTransaction.isActive() &&
+              (
+                !currentSegment ||
+                currentSegment.transaction.id !== scheduledTransaction.id
+              )
+            ) {
+              logger.info(
+                `lost state in ${fileName} (line ${lineNum});`,
+                `expected to be in transaction ${scheduledTransaction.id},`,
+                `instead landed in ${currentSegment && currentSegment.transaction.id}`
+              )
+            }
+            return new Target(...proxyArgs)
+          },
+          apply: function wrappedApply(target, thisArg, args) {
+            const currentSegment = agent.tracer.getSegment()
+            if (
+              scheduledTransaction.isActive() &&
+              (
+                !currentSegment ||
+                currentSegment.transaction.id !== scheduledTransaction.id
+              )
+            ) {
+              logger.info(
+                `lost state in ${fileName} (line ${lineNum});`,
+                `expected to be in transaction ${scheduledTransaction.id},`,
+                `instead landed in ${currentSegment && currentSegment.transaction.id}`
+              )
+            }
+            return target.apply(thisArg, args)
+          }
+        })
+      }
+
+      global.__NR_unwrap = __NR_unwrap
+      function __NR_unwrap(f) {
+        if (typeof f !== 'function' || !f || !f.__NR_new_original) {
+          return f
+        }
+
+        return f.__NR_new_original
+      }
+    }
+
     shimmer.wrapMethod(Module, 'Module', '_resolveFilename', function wrapRes(resolve) {
       return function wrappedResolveFilename(file) {
         // This is triggered by the load call, so record the path that has been seen so

package/lib/spans/span-event-aggregator.js

@@ -40,7 +40,7 @@ class SpanEventAggregator extends EventAggregator {
       spanLogger.trace({
         spansCollected: this.length,
         spansSeen: this.seen
-      }, 'Entity stats on harvest')
+      }, 'Entity stats on span harvest')
     }
     super.send()
   }

package/lib/transaction/index.js

@@ -72,7 +72,6 @@ function Transaction(agent) {
   )
 
   ++agent.activeTransactions
-  ++agent.transactionCreatedInHarvest
 
   this.numSegments = 0
   this.id = hashes.makeId()

package/lib/utilization/common.js

@@ -66,7 +66,8 @@ exports.request = function request(opts, agent, cb) {
     function respond(data) {
       agent.removeListener('errored', abortRequest)
       agent.removeListener('stopped', abortRequest)
-
+      agent.removeListener('disconnected', abortRequest)
+      
       if (res.statusCode !== 200) {
         logger.debug(
           'Got %d %s from metadata request %j',
@@ -83,22 +84,28 @@ exports.request = function request(opts, agent, cb) {
   })
 
   req.setTimeout(1000, function requestTimeout() {
-    logger.debug('Request for metadata %j timed out', opts)
-    cb(new Error('Timeout'))
+    req.abort()
   })
+
   req.on('error', function requestError(err) {
+    if (err.code === 'ECONNRESET') {
+      logger.debug('Request for metadata %j timed out', opts)
+      return cb(err)
+    }
+
     logger.debug('Message for metadata %j: %s', opts, err.message)
     cb(err)
   })
-
   agent.once('errored', abortRequest)
   agent.once('stopped', abortRequest)
+  agent.once('disconnected', abortRequest)
 
   function abortRequest() {
     logger.debug('Aborting request for metadata at %j', opts)
     req.abort()
     agent.removeListener('errored', abortRequest)
     agent.removeListener('stopped', abortRequest)
+    agent.removeListener('disconnected', abortRequest)
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "5.13.0",
+  "version": "5.13.1",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "SEE LICENSE IN LICENSE",
   "contributors": [
@@ -108,7 +108,7 @@
     "clean": "./bin/clean.sh",
     "docker-env": "./bin/docker-env-vars.sh",
     "docs": "npm ci && jsdoc -c ./jsdoc-conf.json --private -r .",
-    "integration": "npm run prepare-test && npm run sub-install && time tap --no-esm test/integration/*.tap.js test/integration/*/*.tap.js test/integration/*/*/*.tap.js --timeout=120",
+    "integration": "npm run prepare-test && npm run sub-install && time tap --no-esm test/integration/**/**/*.tap.js --timeout=120 --no-coverage",
     "prepare-test": "npm ci && npm run ca-gen && npm run ssl && npm run docker-env",
     "lint": "eslint ./*.js lib test",
     "public-docs": "npm ci && jsdoc -c ./jsdoc-conf.json --tutorials examples/shim api.js lib/shim/ lib/transaction/handle.js && cp examples/shim/*.png out/",
@@ -119,7 +119,7 @@
     "ssl": "./bin/ssl.sh",
     "sub-install": "node test/bin/install_sub_deps",
     "test": "npm run integration && npm run unit",
-    "unit": "rm -f newrelic_agent.log && mocha -r nock -c test/unit --recursive",
+    "unit": "rm -f newrelic_agent.log && mocha -r nock -c test/unit --recursive --exit",
     "update-cross-agent-tests": "./bin/update-cats.sh",
     "versioned-tests": "./bin/run-versioned-tests.sh",
     "versioned": "npm run prepare-test && time ./bin/run-versioned-tests.sh"
@@ -133,7 +133,9 @@
     "@tyriar/fibonacci-heap": "^2.0.7",
     "async": "^2.1.4",
     "concat-stream": "^2.0.0",
-    "https-proxy-agent": "^2.2.1",
+    "escodegen": "^1.11.1",
+    "esprima": "^4.0.1",
+    "https-proxy-agent": "^3.0.0",
     "json-stringify-safe": "^5.0.0",
     "readable-stream": "^3.1.1",
     "semver": "^5.3.0"
@@ -158,7 +160,7 @@
     "lodash": "^4.17.14",
     "memcached": ">=0.2.8",
     "minami": "^1.1.1",
-    "mocha": "^5.2.0",
+    "mocha": "^6.2.1",
     "mongodb": "^2",
     "mysql": "*",
     "nock": "9.1.9",
@@ -170,7 +172,7 @@
     "rimraf": "^2.6.3",
     "should": "*",
     "sinon": "^4.5.0",
-    "tap": "^12.7.0",
+    "tap": "^14.6.9",
     "temp": "^0.8.1",
     "through": "^2.3.6",
     "when": "*"

package/lib/event-aggregator.js

@@ -1,94 +0,0 @@
-'use strict'
-
-const logger = require('./logger').child({component: 'event_aggregator'})
-const PriorityQueue = require('./priority-queue')
-
-/**
- * Aggregates events up to a certain limit.
- *
- * @private
- * @class
- */
-class EventAggregator {
-  constructor(limit) {
-    this._events = new PriorityQueue(limit)
-  }
-
-  get limit() {
-    return this._events.limit
-  }
-
-  set limit(limit) {
-    this._events.setLimit(limit)
-  }
-
-  get seen() {
-    return this._events.seen
-  }
-
-  get length() {
-    return this._events.length
-  }
-
-  get overflow() {
-    return this._events.overflow()
-  }
-
-  /**
-   *
-   */
-  getQueue() {
-    return this._events
-  }
-
-  /**
-   * Fetches all the span events aggregated.
-   *
-   * @return {array.<Event>} An array of span events from the aggregator.
-   */
-  getEvents() {
-    return this._events.toArray()
-  }
-
-  /**
-   * Resets the contents of the aggregator and all counters.
-   *
-   * @return {PriorityQueue} The old collection of aggregated events.
-   */
-  clearEvents() {
-    const oldEvents = this._events
-    this._events = new PriorityQueue(this._events.limit)
-    return oldEvents
-  }
-
-  addEvent(event, priority) {
-    return this._events.add(event, priority)
-  }
-
-  /**
-   * Merges a set of events back into the aggregator.
-   *
-   * This should only be used after a failed harvest with the `PriorityQueue`
-   * returned from `EventAggregator#clearEvents`.
-   *
-   * @param {?PriorityQueue} events - The collection of events to re-merge.
-   */
-  mergeEvents(events) {
-    if (!events) {
-      return
-    }
-
-    // We calculate the number that will be merged for the log, but we try to
-    // add every event because we want the ones with the highest priority, not
-    // the first `n` events.
-    const toMerge = Math.min(events.length, this.limit - this.length)
-    logger.warn(
-      'Merging %d of %d events into %s for next harvest',
-      toMerge, events.length, this.constructor.name
-    )
-
-    this._events.merge(events)
-  }
-}
-
-module.exports = EventAggregator