newrelic 4.8.1 → 4.9.0

package/NEWS.md

@@ -1,3 +1,56 @@
+### 4.9.0 (2018-10-01):
+
+* Updated DT payload creation to use `primary_application_id` from connect response.
+
+* Added protection against functions with modified prototypes in `shim.applySegment`.
+
+* Replaced SQL ID hash generation algorithm with SHA1 instead of MD5 to allow usage
+  in FIPS compliant environments.
+
+* Leveraged 16 hex digits for creation of SQL ID.
+
+* Fixed `codec.decode()` callback bug that would re-call a callback with an error
+  thrown within the callback.
+
+* Added `superagent` as built-in instrumentation.
+
+  This instrumentation just maintains transaction state when using the `superagent`
+  module to make HTTP requests with either callbacks or promises.
+
+* Updated `noticeError` API method to be partially functional in High Security Mode.
+
+  In HSM, any custom attributes will be ignored, but the error will still be tracked.
+  This brings the Node agent in line with the behavior of other language agents.
+
+* Upgraded ejs module to get rid of Github security warnings. The ejs module was
+  only used for tests and not in main agent code.
+
+* Fixed bug requiring Cross Application Tracing (CAT) to be enabled for Distributed
+  Tracing (DT) `createDistributedTracePayload` and `acceptDistributedTracePayload`
+  APIs to function. DT configuration will no longer consider CAT configuration.
+
+* Changes DT payload configuration log messages to debug level as it is not uncommon
+  for calls to occur before server configuration has been retrieved.
+
+* Converted `net` instrumentation to use shim api.
+
+* Converted child_process instrumentation to newer shim style.
+
+* Converted Timers instrumentation to newer shim style.
+
+* Fixed bug in wrap() that would fail to wrap callbacks if the callback index was 0.
+
+* Added `PromiseShim` class for instrumenting promise libraries.
+
+* Support for setting `transaction_tracer.transaction_threshold` to 0 has been added.
+
+* The agent now respects `NEW_RELIC_TRACER_THRESHOLD`.
+
+  Previously, this environment variable was stored as a string. The environment
+  variable is now stored as a float.
+
+* Converted zlib instrumentation to use shim API.
+
 ### 4.8.1 (2018-08-27):
 
 * Converted File System instrumentation to use newer shim style.

package/api.js

@@ -397,29 +397,35 @@ API.prototype.setIgnoreTransaction = function setIgnoreTransaction(ignored) {
  *  Optional. Any custom attributes to be displayed in the New Relic UI.
  */
 API.prototype.noticeError = function noticeError(error, customAttributes) {
-  var metric = this.agent.metrics.getOrCreateMetric(
+  const metric = this.agent.metrics.getOrCreateMetric(
     NAMES.SUPPORTABILITY.API + '/noticeError'
   )
   metric.incrementCallCount()
 
-  // If high security mode is on, noticeError is disabled.
-  if (this.agent.config.high_security === true) {
-    logger.warnOnce(
-      'Notice Error',
-      'Notice error API is disabled by high security mode.'
-    )
-    return false
-  } else if (!this.agent.config.api.notice_error_enabled) {
+  if (!this.agent.config.api.notice_error_enabled) {
     logger.debug(
       'Config.api.notice_error_enabled set to false, not collecting error'
     )
     return false
   }
 
+  // If high security mode is on or custom attributes are disabled,
+  // noticeError does not collect custom attributes.
+  if (this.agent.config.high_security === true) {
+    logger.debug(
+      'Passing custom attributes to notice error API is disabled in high security mode.'
+    )
+  } else if (!this.agent.config.api.custom_attributes_enabled) {
+    logger.debug(
+      'Config.api.custom_attributes_enabled set to false, ' +
+      'ignoring custom error attributes.'
+    )
+  }
+
   if (typeof error === 'string') {
     error = new Error(error)
   }
-  var transaction = this.agent.tracer.getTransaction()
+  const transaction = this.agent.tracer.getTransaction()
 
   this.agent.errors.addUserError(transaction, error, customAttributes)
 }

package/bin/travis-setup.sh

@@ -1,9 +1,10 @@
 #! /bin/bash
 
-function get_gcc_version {
-  local gcc_version_match='[[:digit:]]\.[[:digit:]]\.[[:digit:]]'
-  local gcc_version=`$CC --version 2>/dev/null | grep -o "$gcc_version_match" | head -1`
-  echo $gcc_version | grep -o '[[:digit:]]' | head -1
+
+function get_version {
+  local num='[[:digit:]][[:digit:]]*' # Grep doesn't have `+` operator.
+  local version=`$1 --version 2>/dev/null | grep -o "$num\.$num\.$num" | head -1`
+  echo $version | grep -o "$num" | head -1
 }
 
 TOOLCHAIN_ADDED="false"
@@ -15,15 +16,25 @@ function add_toolchain {
   TOOLCHAIN_ADDED="true"
 }
 
-# Only upgrade GCC if we need to.
 
 if [ "$SUITE" = "versioned" ]; then
-  if [ "$(get_gcc_version)" != "5" ]; then
+
+  # GCC 5 is the lowest version of GCC we can use.
+  if [ "$(get_version gcc)" == "4" ]; then
     echo " --- upgrading GCC --- "
     add_toolchain
     ./bin/travis-install-gcc5.sh > /dev/null
   else
-    echo " --- not upgrading GCC --- "
+    echo " --- not upgrading GCC ($(gcc --version)) --- "
+  fi
+
+  # npm 2 has an issue installing correctly for the superagent versioned tests.
+  # TODO: Remove this check when deprecating Node <5.
+  if [ "$(get_version npm)" == "2" ]; then
+    echo " -- upgrading npm --- "
+    npm install -g npm@3
+  else
+    echo " --- not upgrading npm ($(npm --version)) --- "
   fi
 
   echo " --- installing $SUITE requirements --- "

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

@@ -123,6 +123,7 @@ 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
@@ -274,6 +275,7 @@ 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':

package/lib/db/tracer.js

@@ -186,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/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/child_process.js

@@ -1,54 +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) {
-    var wrapped = agent.tracer.wrapFunctionLast('child_process.' + method, null, fn)
-    Object.getOwnPropertySymbols(fn).forEach((symbol) => {
-      wrapped[symbol] = fn[symbol]
-    })
-    return wrapped
-  }
+  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/domain.js

@@ -12,19 +12,20 @@ function initialize(agent, domain, name, shim) {
 
   function wrapEmit(shim, original) {
     return function wrappedEmit(ev) {
-      var shouldRestoreContext = ev === 'error' &&
-          shim.getActiveSegment() === null &&
-          this.__NR_transactionSegment
+      var shouldRestoreContext =
+        ev === 'error' &&
+        shim.getActiveSegment() === null &&
+        shim.getSegment(this)
+
       if (!shouldRestoreContext) {
         return original.apply(this, arguments)
       }
 
-      shim.setActiveSegment(this.__NR_transactionSegment)
+      shim.setActiveSegment(shim.getSegment(this))
       try {
         return original.apply(this, arguments)
       } finally {
         shim.setActiveSegment(null)
-        this.__NR_transactionSegment = null
       }
     }
   }

package/lib/instrumentation/core/net.js

@@ -1,108 +1,104 @@
 'use strict'
 
-var shimmer = require('../../shimmer')
-
-
-module.exports = function initialize(agent, net) {
-  shimmer.wrapMethod(net, 'net', ['connect', 'createConnection'], wrapCreate)
-  function wrapCreate(original, name) {
+module.exports = function initialize(agent, net, moduleName, shim) {
+  shim.wrap(net, ['connect', 'createConnection'], wrapCreate)
+  function wrapCreate(shim, fn, name) {
     return function wrappedCreateConnection() {
-      if (!agent.getTransaction()) {
-        return original.apply(this, arguments)
+      const segment = shim.getActiveSegment()
+      if (!segment) {
+        return fn.apply(this, arguments)
       }
 
-      var segment = agent.tracer.createSegment('net.' + name)
-      var sock = agent.tracer.bindFunction(original, segment, true).apply(this, arguments)
-      wrapSocket(sock, segment)
+      const child = shim.createSegment('net.' + name, null, segment)
+      const sock = shim.applySegment(fn, child, true, this, arguments)
+      wrapSocket(sock, child)
       return sock
     }
   }
 
-  net.Server.prototype.listen = agent.tracer.wrapFunctionNoSegment(
-    net.Server.prototype.listen,
-    'net.Server.prototype.listen'
-  )
-
-  net.Server.prototype.close = agent.tracer.wrapFunctionNoSegment(
-    net.Server.prototype.close,
-    'net.Server.prototype.close'
-  )
-
-  shimmer.wrapMethod(
-    net.Server.prototype,
-    'net.Server.prototype',
-    '_listen2',
-    wrapListen2
-  )
-  shimmer.wrapMethod(
-    net.Socket.prototype,
-    'net.Socket.prototype',
-    'connect',
-    wrapConnect
-  )
-
-  function wrapListen2(original) {
+  const serverProto = net.Server.prototype
+
+  shim.wrap(serverProto, ['listen', 'close'], function wrapNoRecord(shim, fn) {
+    return function wrappedNoRecord() {
+      if (!shim.getActiveSegment()) {
+        return fn.apply(this, arguments)
+      }
+
+      const args = shim.argsToArray.apply(shim, arguments)
+      const cbIndex = args.length - 1
+
+      shim.bindSegment(args, cbIndex)
+
+      return fn.apply(this, args)
+    }
+  })
+
+  shim.wrap(serverProto, '_listen2', wrapListen2)
+  shim.wrap(net.Socket.prototype, 'connect', wrapConnect)
+
+  function wrapListen2(shim, fn) {
     return function wrappedListen2() {
-      var segment = agent.tracer.getSegment()
-      var emit = this.emit
+      const segment = shim.getActiveSegment()
+      const emit = this.emit
 
-      if (!segment || !emit) return original.apply(this, arguments)
+      if (!segment || !emit) return fn.apply(this, arguments)
 
       this.emit = wrappedEmit
 
-      return original.apply(this, arguments)
+      return fn.apply(this, arguments)
 
       function wrappedEmit(ev, socket) {
         if (ev !== 'connection' || !socket || !socket._handle) {
           return emit.apply(this, arguments)
         }
 
-        var child = agent.tracer.createSegment('net.Server.onconnection', null, segment)
+        const child = shim.createSegment('net.Server.onconnection', segment)
 
         if (socket._handle.onread) {
-          socket._handle.onread = agent.tracer.bindFunction(socket._handle.onread, child)
+          shim.bindSegment(socket._handle, 'onread', child)
         }
 
-        return agent.tracer.bindFunction(emit, child, true).apply(this, arguments)
+        return shim.applySegment(emit, child, true, this, arguments)
       }
     }
   }
 
-  function wrapConnect(original) {
+  function wrapConnect(shim, fn) {
     return function connectWrapper() {
-      if (!agent.getTransaction()) return original.apply(this, arguments)
-      var socket = this
-      var args = normalizeConnectArgs(arguments)
-      return agent.tracer.addSegment(
-        'net.Socket.connect',
-        null,
-        null,
-        true,
-        wrappedConnect
-      )
-
-      function wrappedConnect(child) {
-        if (args[1]) args[1] = agent.tracer.bindFunction(args[1], child)
-        var result = original.apply(socket, args)
-        if (socket._handle) {
-          socket._handle.onread = agent.tracer.bindFunction(socket._handle.onread, child)
-        }
-        agent.tracer.bindEmitter(socket, child)
-        return result
+      if (!agent.getTransaction()) {
+        return fn.apply(this, arguments)
+      }
+
+      const socket = this
+      const args = normalizeConnectArgs(arguments)
+
+      const segment = shim.createSegment('net.Socket.connect')
+
+      if (args[1]) {
+        args[1] = shim.bindSegment(args[1], segment)
       }
+
+      const result = shim.applySegment(fn, segment, true, this, args)
+
+      if (socket._handle) {
+        shim.bindSegment(socket._handle, 'onread', segment)
+      }
+      shim.bindSegment(socket, 'emit', segment)
+
+      return result
     }
   }
 
   function wrapSocket(sock, segment) {
-    shimmer.wrapMethod(sock, 'net.Socket', 'emit', function emitWrapper(emit) {
-      return agent.tracer.bindFunction(emit, segment)
+    shim.wrap(sock, 'emit', function emitWrapper(shim, fn) {
+      return shim.bindSegment(fn, segment)
     })
   }
 }
 
 // taken from node master on 2013/10/30
 function normalizeConnectArgs(args) {
-  var options = Object.create(null)
+  let options = Object.create(null)
 
   function toNumber(x) {
     return (x = Number(x)) >= 0 ? x : false
@@ -121,6 +117,6 @@ function normalizeConnectArgs(args) {
     }
   }
 
-  var cb = args[args.length - 1]
+  const cb = args[args.length - 1]
   return typeof cb === 'function' ? [options, cb] : [options]
 }