newrelic 4.6.0 → 4.9.0

package/index.js

@@ -1,21 +1,22 @@
 'use strict'
 
 // Record opening times before loading any other files.
-var preAgentTime = process.uptime()
-var agentStart = Date.now()
+const preAgentTime = process.uptime()
+const agentStart = Date.now()
 
 // Load unwrapped core now to ensure it gets the freshest properties.
 require('./lib/util/unwrapped-core')
 
-var featureFlags = require('./lib/feature_flags').prerelease
-var logger = require('./lib/logger')
-var psemver = require('./lib/util/process-version')
+const featureFlags = require('./lib/feature_flags').prerelease
+const psemver = require('./lib/util/process-version')
+let logger = require('./lib/logger') // Gets re-loaded after initialization.
 
 
-var agentVersion = require('./package.json').version
+const pkgJSON = require('./package.json')
 logger.info(
-  "Using New Relic for Node.js. Agent version: %s; Node version: %s.",
-  agentVersion, process.version
+  'Using New Relic for Node.js. Agent version: %s; Node version: %s.',
+  pkgJSON.version,
+  process.version
 )
 
 if (require.cache.__NR_cache) {
@@ -49,6 +50,13 @@ function initialize() {
 
       logger.error(message)
       throw new Error(message)
+    } else if (!psemver.satisfies(pkgJSON.engines.node)) {
+      logger.warn(
+        'New Relic for Node.js %s has not been tested on Node.js %s. Please ' +
+        'update the agent or downgrade your version of Node.js',
+        pkgJSON.version,
+        process.version
+      )
     }
 
     logger.debug("Current working directory at module load is %s.", process.cwd())

package/lib/collector/remote-method.js

@@ -10,6 +10,7 @@ var stringify = require('json-stringify-safe')
 var Sink = require('../util/stream-sink')
 var agents = require('./http-agents')
 var certificates = require('./ssl/certificates')
+const isValidLength = require('../util/byte-limit').isValidLength
 
 /*
  *
@@ -147,8 +148,19 @@ RemoteMethod.prototype._safeRequest = function _safeRequest(options) {
   var protocol = 'https'
   var logConfig = this._config.logging
   var auditLog = this._config.audit_log
+  const maxPayloadSize = this._config.max_payload_size_in_bytes
   var level = 'trace'
 
+  if (!isValidLength(options.body, maxPayloadSize + 1)) {
+    logger.warn(
+      'The payload size %d being sent to method %s exceeded the maximum size of %d',
+      Buffer.byteLength(options.body, 'utf8'),
+      this.name,
+      maxPayloadSize
+    )
+    throw new Error('Maximum payload size exceeded')
+  }
+
   // If trace level is not explicity enabled check to see if the audit log is
   // enabled.
   if (logConfig != null && logConfig.level !== 'trace' && auditLog.enabled) {

package/lib/config/default.js

@@ -793,6 +793,11 @@ exports.config = {
 
   /**
    * Controls the method of cross agent tracing in the agent.
+   * Distributed tracing lets you see the path that a request takes through your
+   * distributed system. Enabling distributed tracing changes the behavior of some
+   * New Relic features, so carefully consult the transition guide before you enable
+   * this feature: https://docs.newrelic.com/docs/transition-guide-distributed-tracing
+   * Default is false.
    */
   distributed_tracing: {
     /**

package/lib/config/env.js

@@ -184,7 +184,8 @@ const BOOLEAN_VARS = new Set([
 ])
 
 const FLOAT_VARS = new Set([
-  'NEW_RELIC_APDEX'
+  'NEW_RELIC_APDEX',
+  'NEW_RELIC_TRACER_THRESHOLD'
 ])
 
 const INT_VARS = new Set([

package/lib/config/index.js

@@ -21,6 +21,7 @@ var logger = null // Lazy-loaded in `initialize`.
 /**
  * CONSTANTS -- we gotta lotta 'em
  */
+const DEFAULT_MAX_PAYLOAD_SIZE_IN_BYTES = 1000000
 const DEFAULT_CONFIG_PATH = require.resolve('./default')
 const DEFAULT_CONFIG = require('./default').config
 const DEFAULT_FILENAME = 'newrelic.js'
@@ -122,10 +123,12 @@ function Config(config) {
   this.cross_process_id = null
   this.encoding_key = null
   this.obfuscatedId = null
+  this.primary_application_id = null
   this.trusted_account_ids = null
   this.trusted_account_key = null
   this.sampling_target = 10
   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
@@ -272,7 +275,9 @@ Config.prototype._fromServer = function _fromServer(params, key) {
     case 'application_id':
     case 'collect_errors':
     case 'collect_traces':
+    case 'primary_application_id':
     case 'product_level':
+    case 'max_payload_size_in_bytes':
     case 'sampling_target':
     case 'sampling_target_period_in_seconds':
     case 'trusted_account_ids':

package/lib/db/tracer.js

@@ -46,27 +46,36 @@ QueryTracer.prototype.merge = function merge(tracer) {
 
 QueryTracer.prototype.addQuery = function addQuery(segment, type, query, trace) {
   const ttConfig = this.config.transaction_tracer
-  if (segment.getDurationInMillis() < ttConfig.explain_threshold) {
-    return
-  }
-  const slowQuery = new SlowQuery(segment, type, query, trace)
 
+  // If DT is enabled and the segment is part of a sampled transaction
+  // (i.e. we are creating a span event for this segment), then we need
+  // to collect the sql trace.
+  var slowQuery
   switch (ttConfig.record_sql) {
     case 'raw':
+      slowQuery = new SlowQuery(segment, type, query, trace)
       logger.trace('recording raw sql')
       segment.parameters.sql = slowQuery.query
       break
     case 'obfuscated':
+      slowQuery = new SlowQuery(segment, type, query, trace)
       logger.trace('recording obfuscated sql')
       segment.parameters.sql_obfuscated = slowQuery.obfuscated
       break
     default:
       logger.trace(
-        'not collecting slow-query because transaction_tracer.record_sql was set to %s',
+        'not recording sql statement, transaction_tracer.record_sql was set to %s',
         ttConfig.record_sql
       )
       return
   }
+
+  if (segment.getDurationInMillis() < ttConfig.explain_threshold) {
+    return
+  }
+
+  slowQuery = slowQuery || new SlowQuery(segment, type, query, trace)
+
   segment.parameters.backtrace = slowQuery.trace
 
   if (!this.config.slow_sql.enabled) {
@@ -177,7 +186,9 @@ function SlowQuery(segment, type, query, trace) {
 }
 
 function normalizedHash(value) {
-  return parseInt(crypto.createHash('md5').update(value).digest('hex').slice(-4), 16)
+  // We leverage the last 16 hex digits of which would mostly fit in a long and
+  // rely on parseInt to drop bits that do not fit in a JS number
+  return parseInt(crypto.createHash('sha1').update(value).digest('hex').slice(-16), 16)
 }
 
 function formatTrace(trace) {

package/lib/environment.js

@@ -305,7 +305,7 @@ function getGlobalPackages(cb) {
  * package appears at most once, with all the versions joined into a
  * comma-delimited list.
  *
- * @return {Array.<String>[]} Sorted list of [name, version] pairs.
+ * @return {Array.<string[]>} Sorted list of [name, version] pairs.
  */
 function flattenVersions(packages) {
   var info = Object.create(null)

package/lib/errors/index.js

@@ -74,7 +74,7 @@ function createError(transaction, exception, customAttributes, config) {
     }
   }
 
-  if (!config.high_security && customAttributes) {
+  if (!config.high_security && config.api.custom_attributes_enabled && customAttributes) {
     for (var key in customAttributes) {
       if (props.hasOwn(customAttributes, key)) {
         var dest = config.attributeFilter.filter(DESTINATIONS.ERROR_EVENT, key)

package/lib/instrumentation/bluebird.js

@@ -1,39 +1,5 @@
 'use strict'
 
-var promInit = require('./promise')
-var shimmer = require('../shimmer')
-
-var BLUEBIRD_SPEC = {
-  name: 'bluebird',
-  constructor: 'Promise',
-  $proto: {
-    cast: [
-      'all', 'any', 'bind', 'call', 'catchReturn', 'catchThrow', 'delay', 'get',
-      'props', 'race', 'reflect', 'return', 'some', 'thenReturn', 'thenThrow',
-      'throw', 'timeout'
-    ],
-    then: [
-      'asCallback', 'done', 'each', 'filter', 'finally', 'lastly', 'map',
-      'mapSeries', 'nodeify', 'reduce', 'spread', 'tap', 'tapCatch', 'then'
-    ],
-    catch: ['catch', 'caught', 'error'],
-
-    // _resolveFromResolver is in bluebird 2.x
-    // _execute is in bluebird 3.x
-    executor: ['_execute', '_resolveFromResolver']
-  },
-  $static: {
-    cast: [
-      'all', 'any', 'attempt', 'bind', 'cast', 'delay', 'each', 'filter',
-      'fromCallback', 'fromNode', 'fulfilled', 'join', 'map', 'mapSeries',
-      'props', 'race', 'reduce', 'reject', 'rejected', 'resolve', 'some', 'try'
-    ],
-    promisify: [
-      'coroutine', 'method', 'promisify'
-    ]
-  }
-}
-
 // XXX We are not instrumenting bluebird's cancellation feature because it seems
 // rather like an edge case feature. It is not enabled by default and has strange
 // effects on the interface. If our lack of support for cancellation becomes an
@@ -41,31 +7,55 @@ var BLUEBIRD_SPEC = {
 //
 // http://bluebirdjs.com/docs/api/cancellation.html
 
+module.exports = function initialize(agent, bluebird, moduleName, shim) {
+  const Promise = bluebird.Promise
+  const proto = Promise && Promise.prototype
+  if (!proto) {
+    shim.logger.debug('Could not find promise prototype, not instrumenting.')
+    return false
+  }
 
-module.exports = function initialize(agent, bluebird) {
-  promInit(agent, bluebird, BLUEBIRD_SPEC)
+  shim.setClass(Promise)
+
+  // _resolveFromResolver is in bluebird 2.x
+  // _execute is in bluebird 3.x
+  shim.wrapExecutorCaller(proto, ['_execute', '_resolveFromResolver'])
+  shim.wrapThen(proto, [
+    'asCallback', 'done', 'each', 'filter', 'finally', 'lastly', 'map',
+    'mapSeries', 'nodeify', 'reduce', 'spread', 'tap', 'tapCatch', 'then'
+  ])
+  shim.wrapCatch(proto, ['catch', 'caught', 'error'])
+  shim.wrapCast(proto, [
+    'all', 'any', 'bind', 'call', 'catchReturn', 'catchThrow', 'delay', 'get',
+    'props', 'race', 'reflect', 'return', 'some', 'thenReturn', 'thenThrow',
+    'throw', 'timeout'
+  ])
+
+  shim.wrapCast(Promise, [
+    'all', 'any', 'attempt', 'bind', 'cast', 'delay', 'each', 'filter',
+    'fromCallback', 'fromNode', 'fulfilled', 'join', 'map', 'mapSeries',
+    'props', 'race', 'reduce', 'reject', 'rejected', 'resolve', 'some', 'try'
+  ])
+  shim.wrapPromisify(Promise, ['coroutine', 'method', 'promisify'])
 
   // Using `getNewLibraryCopy` needs to trigger re-instrumenting.
-  shimmer.wrapMethod(
+  shim.wrap(
     bluebird.Promise,
-    'bluebird',
     'getNewLibraryCopy',
-    function wrapNewCopy(original) {
+    function wrapNewCopy(shim, original) {
       return function wrappedNewCopy() {
+        shim.logger.trace('Instrumenting new library copy...')
         var copy = original.apply(this, arguments)
-        module.exports(agent, copy)
+        module.exports(agent, copy, moduleName, shim)
         return copy
       }
     }
   )
 
   // Need to copy over `coroutine.addYieldHandler`
-  var Promise = bluebird.Promise
   var coroutine = Promise && Promise.coroutine
-  if (shimmer.isWrapped(coroutine)) {
-    var original = agent.tracer.getOriginal(coroutine)
+  if (shim.isWrapped(coroutine)) {
+    var original = shim.getOriginal(coroutine)
     coroutine.addYieldHandler = original && original.addYieldHandler
   }
 }
-
-module.exports.SPEC = BLUEBIRD_SPEC

package/lib/instrumentation/core/async_hooks.js

@@ -24,9 +24,9 @@ var NATIVE_PROMISE_SPEC = {
   }
 }
 
-function initialize(agent) {
+function initialize(agent, shim) {
   var enableHooks = agent.config.checkAsyncHookStatus()
-  if (enableHooks && tryAsyncHooks(agent)) {
+  if (enableHooks && tryAsyncHooks(agent, shim)) {
     logger.debug('Using async_hooks.')
   } else {
     logger.debug('Using promise instrumentation.')
@@ -34,7 +34,7 @@ function initialize(agent) {
   }
 }
 
-function tryAsyncHooks(agent) {
+function tryAsyncHooks(agent, shim) {
   var asyncHooks = null
   try {
     asyncHooks = require('async_hooks')
@@ -57,7 +57,7 @@ function tryAsyncHooks(agent) {
         return
       }
 
-      var activeSegment = agent.tracer.getSegment() || parentSegment
+      var activeSegment = shim.getActiveSegment() || parentSegment
       if (promiseWrap && promiseWrap.promise) {
         promiseWrap.promise.__NR_id = id
       }
@@ -71,8 +71,8 @@ function tryAsyncHooks(agent) {
         return
       }
 
-      segmentMap.set(id, agent.tracer.getSegment())
-      agent.tracer.segment = hookSegment
+      segmentMap.set(id, shim.getActiveSegment())
+      shim.setActiveSegment(hookSegment)
     },
     after: function afterHook(id) {
       var hookSegment = segmentMap.get(id)
@@ -85,8 +85,8 @@ function tryAsyncHooks(agent) {
         return
       }
 
-      segmentMap.set(id, agent.tracer.getSegment())
-      agent.tracer.segment = hookSegment
+      segmentMap.set(id, shim.getActiveSegment())
+      shim.setActiveSegment(hookSegment)
     },
     destroy: function destHook(id) {
       segmentMap.delete(id)

package/lib/instrumentation/core/child_process.js

@@ -1,50 +1,57 @@
 'use strict'
 
-var wrap = require('../../shimmer').wrapMethod
-var isWrapped = require('../../shimmer').isWrapped
-
 module.exports = initialize
 
-function initialize(agent, childProcess) {
-  var methods = ['exec', 'execFile']
+function initialize(agent, childProcess, moduleName, shim) {
+  if (!childProcess) {
+    shim.log.debug('Could not find child_process, not instrumenting')
+    return false
+  }
 
-  wrap(childProcess, 'childProcess', methods, wrapMethod)
+  const methods = ['exec', 'execFile']
 
-  function wrapMethod(fn, method) {
-    return agent.tracer.wrapFunctionLast('child_process.' + method, null, fn)
-  }
+  shim.record(
+    childProcess,
+    methods,
+    function recordExec(shim, fn, name) {
+      return {name: 'child_process.' + name, callback: shim.LAST}
+    }
+  )
 
-  var childProcessProto = childProcess && childProcess.ChildProcess
-  // ChildProcess is exposed on Node 4 and higher
-  if (childProcessProto) {
-    wrapChildProcessCls(childProcess.ChildProcess)
+  if (childProcess.ChildProcess) {
+    wrapChildProcessClass(shim, childProcess.ChildProcess)
   } else {
-    wrap(childProcess, 'childProcess', ['fork', 'spawn'], wrapSpawn)
+    shim.logger.warn('childProcess.ChildProcess should be available in v2.2.0 or higher')
   }
 
-  function  wrapSpawn(fn) {
-    return function wrapped() {
-      var child = fn.apply(this, arguments)
-      if (child && child.constructor && child.constructor.prototype) {
-        wrapChildProcessCls(child.constructor)
-      }
-      return child
-    }
-  }
+  function wrapChildProcessClass(shim, childProcessClass) {
+    shim.wrap(
+      childProcessClass.prototype,
+      'on',
+      function wrapChildProcessClassOn(shim, fn) {
+        return function wrappedChildProcessOn() {
+          const args = shim.argsToArray.apply(shim, arguments)
+          const cbIndex = args.length - 1
 
-  function wrapChildProcessCls(childProcessCls) {
-    if (!childProcessCls || !childProcessCls.prototype ||
-      isWrapped(childProcessCls.prototype.on)) {
-      return
-    }
+          shim.bindSegment(args, cbIndex)
 
-    wrap(
-      childProcessCls.prototype,
-      'childProcess.ChildProcess.prototype',
-      'on',
-      function wrapEmit(fn) {
-        return agent.tracer.wrapFunctionNoSegment(fn, ['on', 'addListener'])
+          return fn.apply(this, args)
+        }
       }
     )
   }
+
+  makePromisifyCompatible(shim, childProcess)
+}
+
+function makePromisifyCompatible(shim, childProcess) {
+  const originalExec = shim.getOriginal(childProcess.exec)
+  Object.getOwnPropertySymbols(originalExec).forEach((symbol) => {
+    childProcess.exec[symbol] = originalExec[symbol]
+  })
+
+  const originalExecFile = shim.getOriginal(childProcess.execFile)
+  Object.getOwnPropertySymbols(originalExecFile).forEach((symbol) => {
+    childProcess.execFile[symbol] = originalExecFile[symbol]
+  })
 }

package/lib/instrumentation/core/crypto.js

@@ -1,13 +1,10 @@
 'use strict'
 
-var wrap = require('../../shimmer').wrapMethod
-
 module.exports = initialize
 
-function initialize(agent, crypto) {
-  wrap(
+function initialize(agent, crypto, moduleName, shim) {
+  shim.record(
     crypto,
-    'crypto',
     [
       'pbkdf2',
       'randomBytes',
@@ -15,14 +12,12 @@ function initialize(agent, crypto) {
       'randomFill',
       'scrypt'
     ],
-    wrapCryptoMethod
-  )
-
-  function wrapCryptoMethod(fn, method) {
-    return agent.tracer.wrapFunctionLast('crypto.' + method, null, wrappedCrypto)
-
-    function wrappedCrypto() {
-      return fn.apply(this, arguments)
+    function recordCryptoMethod(shim, fn, name) {
+      return {
+        name: 'crypto.' + name,
+        callback: shim.LAST,
+        callbackRequired: true // sync version used too heavily - too much overhead
+      }
     }
-  }
+  )
 }

package/lib/instrumentation/core/dns.js

@@ -1,11 +1,9 @@
 'use strict'
 
-var shimmer = require('../../shimmer')
-
 module.exports = initialize
 
-function initialize(agent, dns) {
-  var methods = [
+function initialize(agent, dns, moduleName, shim) {
+  const methods = [
     'lookup',
     'resolve',
     'resolve4',
@@ -20,13 +18,11 @@ function initialize(agent, dns) {
     'reverse'
   ]
 
-  shimmer.wrapMethod(dns, 'dns', methods, function wrapMethods(fn, method) {
-    return agent.tracer.wrapFunction('dns.' + method, null, fn, wrapDnsArgs)
-  })
-
-  function wrapDnsArgs(segment, args) {
-    var lastIdx = args.length - 1
-    args[lastIdx] = agent.tracer.bindFunction(args[lastIdx], segment, true)
-    return args
-  }
+  shim.record(
+    dns,
+    methods,
+    function recordDnsMethod(shim, fn, name) {
+      return { name: 'dns.' + name, callback: shim.LAST }
+    }
+  )
 }

package/lib/instrumentation/core/domain.js

@@ -1,33 +1,31 @@
 'use strict'
 
-var wrap = require('../../shimmer').wrapMethod
-
 module.exports = initialize
 
-function initialize(agent, domain) {
+function initialize(agent, domain, name, shim) {
   var proto = domain.Domain.prototype
-  wrap(
+  shim.wrap(
     proto,
-    'domain.Domain.prototype',
     'emit',
     wrapEmit
   )
 
-  function wrapEmit(original) {
+  function wrapEmit(shim, original) {
     return function wrappedEmit(ev) {
-      var shouldRestoreContext = ev === 'error' &&
-          agent.tracer.segment === null &&
-          this.__NR_transactionSegment
+      var shouldRestoreContext =
+        ev === 'error' &&
+        shim.getActiveSegment() === null &&
+        shim.getSegment(this)
+
       if (!shouldRestoreContext) {
         return original.apply(this, arguments)
       }
 
-      agent.tracer.segment = this.__NR_transactionSegment
+      shim.setActiveSegment(shim.getSegment(this))
       try {
         return original.apply(this, arguments)
       } finally {
-        agent.tracer.segment = null
-        this.__NR_transactionSegment = null
+        shim.setActiveSegment(null)
       }
     }
   }