newrelic 2.1.0 → 2.2.0

package/.eslintrc

@@ -4,6 +4,7 @@
     "browser": false
   },
   "globals": {
+    "Map": true,
     "Promise": true
   },
   "rules": {

package/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,5 @@
+## CHANGE LOG
+
+## INTERNAL LINKS
+
+## NOTES

package/NEWS.md

@@ -1,14 +1,50 @@
 
-### v2.1.0 (2017-08-08)
+### v2.2.0 (2017-08-22):
+* Added support for ignoring ranges of status codes.
+
+  The configuration `error_collector.ignore_status_codes` can now take ranges
+  of numbers. For example, `ignore_status_codes: ['400-404']` would ignore 400,
+  401, 402, 403, and 404.
+
+* Fixed a bug when a custom collector port was provided in the configuration
+  that prevented redirected connections from working.
+
+* Fixed a bug in `Shim#record` that could cause an exception when trying to
+  create a new segment as part of an ended/inactive transaction.
+
+* Fixed issue with custom Hapi handlers causing an error.
+
+  Previously custom Hapi handlers defined using the `server.handler()` method
+  were causing the Hapi server to return a 500 error. Now they are correctly
+  handled and recorded as middleware functions.
+
+* Transaction state is now maintained in `ChildProcess` event listeners.
+
+* Updated examples and documentation regarding custom transaction creation.
+
+  All examples and documentation now point at the `newrelic.start*Transaction`
+  methods.
+
+* Reducing logging verbosity in the SQL query obfuscator.
+
+* Experimental instrumentation for `async/await`
+
+  This is experimental instrumentation and has not yet been tested in a wide
+  array of production environments. The feature is currently off by default
+  behind a feature flag. To enable this experimental instrumentation, add
+  `await_support: true` to the `feature_flag` setting in your agent config
+  file.
+
+### v2.1.0 (2017-08-08):
 * Improved metadata collection for AWS, Azure, GCE, and Pivotal Cloud Foundry.
 
 * Fixed a bug in PG query obfuscation for `$` placeholders.
 
-  The agent used to mis-detect `$1` value placeholders as unmatched dollar-quoted
-  strings causing the whole query to be obfuscated to just `?`. These
-  placeholders are now correctly detected and obfuscated.
+  The agent used to mis-detect `$1` value placeholders as unmatched
+  dollar-quoted strings causing the whole query to be obfuscated to just `?`.
+  These placeholders are now correctly detected and obfuscated.
 
-### v2.0.2 (2017-08-01)
+### v2.0.2 (2017-08-01):
 * Improved documentation for `newrelic.start*Transaction` and `TransactionHandle.`
 
   Formatting for the `startWebTransaction` and `startBackgroundTransaction`
@@ -22,7 +58,7 @@
 
 * Fixed unhandled rejection error caused by `ioredis` instrumentation.
 
-### v2.0.1 (2017-07-25)
+### v2.0.1 (2017-07-25):
 * Fixed issue with transaction events not including correct duration values.
 
   This issue was introduced in v2.0.0, and it has affected web transactions histogram

package/README.md

@@ -656,7 +656,7 @@ application, the agent can't tell when they should begin and end.
 Read more at:
 https://docs.newrelic.com/docs/agents/nodejs-agent/supported-features/nodejs-custom-instrumentation
 
-#### newrelic.createWebTransaction(url, handle)
+#### newrelic.startWebTransaction(url, handle)
 
 `url` is the name of the web transaction. It should be pretty static, not
 including anything like user ids or any other data that is very specific to the
@@ -669,16 +669,22 @@ called within an active background transaction, it will create a new,
 independent transaction and any calls within the `handle` will be bound to the
 new web transaction.
 
-Custom transactions **must** be ended manually by calling `endTransaction()`.
-Timing for custom transaction starts from when the returned wrapped function is
-called until `endTransaction()` is called.
+Custom transactions can be ended within the `handle` in one of three ways:
 
-#### newrelic.createBackgroundTransaction(name, [group], handle)
+1. Call `transaction.end()`. The `transaction` can be received by calling
+  `newrelic.getTransaction()` first thing in the handler function. Then,
+  when you call `transaction.end()` timing will stop.
+2. Return a promise. The transaction will end when the promise resolves or
+  rejects.
+3. Do neither. If no promise is returned, and `getTransaction()` isn't
+  called, the transaction will end immediately after the handle returns.
+
+#### newrelic.startBackgroundTransaction(name [, group], handle)
 
 `name` is the name of the job. It should be pretty static, and not include job
 ids or anything very specific to that run of the job. `group` is optional, and
 allows you to group types of jobs together. This should follow similar rules as
-the `name`. `handle` is a function that encompases your background job. Both
+the `name`. `handle` is a function that encompasses your background job. Both
 custom and auto instrumentation will be captured as part of the transaction.
 
 If called within an active background transaction, it will act as a nested
@@ -686,14 +692,20 @@ tracer. If called within an active web transaction, it will create a new
 transaction and any calls within the `handle` will be bound to the new,
 independent background transaction.
 
-Custom transactions **must** be ended manually by calling `endTransaction()`.
-Timing for custom transaction starts from when the returned wrapped function is
-called until `endTransaction()` is called.
+1. Call `transaction.end()`. The `transaction` can be received by calling
+  `newrelic.getTransaction()` first thing in the handler function. Then,
+  when you call `transaction.end()` timing will stop.
+2. Return a promise. The transaction will end when the promise resolves or
+  rejects.
+3. Do neither. If no promise is returned, and `getTransaction()` isn't
+  called, the transaction will end immediately after the handle returns.
 
-#### newrelic.endTransaction()
+#### newrelic.getTransaction()
 
-This takes no arguments and must be called to end any custom transaction. It
-will detect what kind of transaction was active and end it.
+This takes no arguments and returns the currently active transaction. If the
+returned transaction is a custom one, started with either `startWebTransaction`
+or `startBackgroundTransaction`, then `transaction.end()` must be called to
+end the transaction.
 
 #### newrelic.createTracer(name, handle)
 

package/api.js

@@ -91,6 +91,7 @@ API.prototype.setTransactionName = function setTransactionName(name) {
     return
   }
 
+  logger.trace('Setting transaction %s name to %s', transaction.id, name)
   transaction.forceName = NAMES.CUSTOM + '/' + name
 }
 
@@ -623,8 +624,7 @@ API.prototype.createTracer = function createTracer(name, callback) {
 }
 
 API.prototype.createWebTransaction = util.deprecate(
-  createWebTransaction,
-  [
+  createWebTransaction, [
     'API#createWebTransaction is being deprecated!',
     'Please use API#startWebTransaction for transaction creation',
     'and API#getTransaction for transaction management including',
@@ -884,8 +884,7 @@ function startBackgroundTransaction(name, group, handle) {
 }
 
 API.prototype.createBackgroundTransaction = util.deprecate(
-  createBackgroundTransaction,
-  [
+  createBackgroundTransaction, [
     'API#createBackgroundTransaction is being deprecated!',
     'Please use API#startBackgroundTransaction for transaction creation',
     'and API#getTransaction for transaction management including',
@@ -1074,7 +1073,7 @@ API.prototype.recordMetric = function recordMetric(name, value) {
 
   for (var i = 0, l = required.length; i < l; ++i) {
     if (typeof value[required[i]] !== 'number') {
-      logger.warn('Metric object must include ' + required[i] + ' as a number')
+      logger.warn('Metric object must include %s as a number', required[i])
       return
     }
 

package/index.js

@@ -17,6 +17,9 @@ if (require.cache.__NR_cache) {
     'Attempting to load a second copy of newrelic from %s, using cache instead',
     __dirname
   )
+  if (require.cache.__NR_cache.agent) {
+    require.cache.__NR_cache.agent.recordSupportability('Agent/DoubleLoad')
+  }
   module.exports = require.cache.__NR_cache
 } else {
   initialize()
@@ -88,9 +91,10 @@ function initialize() {
       agent.start(function cb_start(error) {
         if (!error) {
           // TODO: After deprecating Node 0.10 and 0.12, simplify this regex.
+          // TODO: As new versions come out, make sure to update Angler metrics.
           var nodeMajor = /^v?((?:0\.)?\d+)/.exec(process.version)
-          agent.metrics.getOrCreateMetric(
-            'Supportability/Nodejs/Version/' + ((nodeMajor && nodeMajor[1]) || 'unknown')
+          agent.recordSupportability(
+            'Version/' + ((nodeMajor && nodeMajor[1]) || 'unknown')
           )
 
           return logger.debug("New Relic for Node.js is connected to New Relic.")

package/lib/agent.js

@@ -107,6 +107,7 @@ function Agent(config) {
   this.segmentsCreatedInHarvest = 0
   this.segmentsClearedInHarvest = 0
   this.activeTransactions = 0
+  this.transactionCreatedInHarvest = 0
 
   // Hidden class optimizations.
   this.harvesterHandle = null
@@ -286,9 +287,11 @@ Agent.prototype.harvest = function harvest(callback) {
     harvestCleared: this.segmentsClearedInHarvest,
     activeTransactions: this.activeTransactions
   }, 'Entity stats on harvest')
+  this.recordSupportability('Transactions/Created', this.transactionCreatedInHarvest)
 
   this.segmentsCreatedInHarvest = 0
   this.segmentsClearedInHarvest = 0
+  this.transactionCreatedInHarvest = 0
 
   if (!this.collector.isConnected()) {
     return process.nextTick(function cb_nextTick() {
@@ -994,7 +997,7 @@ Agent.prototype._transactionFinished = function _transactionFinished(transaction
     logger.debug('Ignoring %s (%s).', transaction.name, transaction.id)
   }
 
-  this.activeTransactions--
+  --this.activeTransactions
   this.totalActiveSegments -= transaction.numSegments
   this.segmentsClearedInHarvest += transaction.numSegments
 }
@@ -1008,4 +1011,13 @@ Agent.prototype.getTransaction = function getTransaction() {
   return this.tracer.getTransaction()
 }
 
+Agent.prototype.recordSupportability = function recordSupportability(name, value) {
+  var metric = this.metrics.getOrCreateMetric(NAMES.SUPPORTABILITY.NODEJS + '/' + name)
+  if (value != null) {
+    metric.recordValue(value)
+  } else {
+    metric.incrementCallCount()
+  }
+}
+
 module.exports = Agent

package/lib/collector/api.js

@@ -42,11 +42,11 @@ var HTTP_LOL_COLLECTOR = 503
 function dumpErrors(errors, name) {
   var index = 1
 
-  errors.forEach(function cb_forEach(error) {
+  errors.forEach(function forEachError(error) {
     logger.trace(error, "Error %s during %s:", index++, name)
 
     if (error.laterErrors) {
-      error.laterErrors.forEach(function cb_forEach(laterError) {
+      error.laterErrors.forEach(function forEachLaterError(laterError) {
         logger.trace(laterError, "Error %s during %s:", index++, name)
       })
     }
@@ -115,7 +115,7 @@ CollectorAPI.prototype.connect = function connect(callback) {
     var id = setTimeout(function again() {
       api._login(retry)
     }, backoff.interval * TO_MILLIS)
-    
+
     if (id.unref) {
       id.unref()
     }
@@ -129,7 +129,7 @@ CollectorAPI.prototype._login = function _login(callback) {
   var agent = this._agent
 
 
-  methods.redirect.invoke(null, function cb_invoke(error, collector, body) {
+  methods.redirect.invoke(null, function redirectCb(error, collector, body) {
     if (error) return callback(error, collector, body)
     if (!collector) {
       logger.error(
@@ -152,18 +152,20 @@ CollectorAPI.prototype._login = function _login(callback) {
         )
 
         agent.config.host = parts[0]
-        if (parts.length > 1) {
-          agent.config.port = parts[1]
-        }
+        agent.config.port = parts[1] || (agent.config.ssl ? 443 : 80)
       }
     }
 
+    _getFacts()
+  })
+
+  function _getFacts() {
     facts(agent, function getEnvDict(environmentDict) {
       // The collector really likes arrays.
       // In fact, it kind of insists on them.
       var environment = [environmentDict]
 
-      methods.handshake.invoke(environment, function cb_invoke(error, config, body) {
+      methods.handshake.invoke(environment, function handshakeCb(error, config, body) {
         if (error) return callback(error, config, body)
         if (!config || !config.agent_run_id) {
           return callback(new Error("No agent run ID received from handshake."), config)
@@ -183,7 +185,7 @@ CollectorAPI.prototype._login = function _login(callback) {
         callback(null, config, body)
       })
     })
-  })
+  }
 }
 
 /**

package/lib/config.js

@@ -12,6 +12,7 @@ var exists = fs.existsSync || path.existsSync
 var safeJSON = require('./util/safe-json')
 var stringifySync = safeJSON.stringifySync
 var parse = safeJSON.parse
+var semver = require('semver')
 var os = require('os')
 var logger
 
@@ -727,6 +728,19 @@ Config.prototype.logUnknown = function logUnknown(json, key) {
   )
 }
 
+/**
+ * Return the availability of async_hook for use by the agent.
+ */
+Config.prototype.checkAsyncHookStatus = function checkAsyncHookStatus() {
+  return (
+    (
+      semver.satisfies(process.version, '>=8') ||
+      semver.prerelease(process.version)
+    ) &&
+    this.feature_flag.await_support
+  )
+}
+
 /**
  * Gets the user set host display name. If not provided, it returns the default value.
  *
@@ -948,13 +962,59 @@ Config.prototype._fromEnvironment = function _fromEnvironment(metadata, data) {
  * based on special properties of configuration values should go here as well.
  */
 Config.prototype._canonicalize = function _canonicalize() {
-  var codes = this.error_collector && this.error_collector.ignore_status_codes
-  if (codes) {
-    this.error_collector.ignore_status_codes = codes.map(function cb_map(code) {
-      return parseInt(code, 10)
-    })
+  function parseCodes(codes) {
+    // range does not support negative values
+    function parseRange(range, parsed) {
+      var split = range.split('-')
+      if (split.length !== 2) {
+        logger.warn('Failed to parse range %s', range)
+        return parsed
+      }
+      if (split[0] === '') { // catch negative code. ex. -7
+        return parsed.push(parseInt(range, 10))
+      }
+      var lower = parseInt(split[0], 10)
+      var upper = parseInt(split[1], 10)
+      if (Number.isNaN(lower) || Number.isNaN(upper)) {
+        logger.warn('Range must contain two numbers %s', range)
+        return parsed
+      }
+      if (lower > upper) {
+        logger.warn('Range must start with lower bound %s', range)
+      } else if (lower < 0 || upper > 1000) {
+        logger.warn('Range must be between 0 and 1000 %s', range)
+      } else { // success
+        for (var i = lower; i <= upper; i++) {
+          parsed.push(i)
+        }
+      }
+      return parsed
+    }
+
+    var parsedCodes = []
+    for (var i = 0; i < codes.length; i++) {
+      var code = codes[i]
+      var parsedCode
+      if (typeof code === 'string' && code.indexOf('-') !== -1) {
+        parseRange(code, parsedCodes)
+      } else {
+        parsedCode = parseInt(code, 10)
+        if (!Number.isNaN(parsedCode)) {
+          parsedCodes.push(parsedCode)
+        } else {
+          logger.warn('Failed to parse status code %s', code)
+        }
+      }
+    }
+    return parsedCodes
   }
 
+  var statusCodes = this.error_collector && this.error_collector.ignore_status_codes
+  if (statusCodes) {
+    this.error_collector.ignore_status_codes = parseCodes(statusCodes)
+  }
+
+
   var logAliases = {
     'verbose': 'trace',
     'debugging': 'debug',
@@ -1020,10 +1080,10 @@ Config.prototype.measureInternal = function measureInternal(suffix, duration) {
 Config.prototype.validateFlags = function validateFlags() {
   Object.keys(this.feature_flag).forEach(function cb_forEach(key) {
     if (feature_flag.released.indexOf(key) > -1) {
-      logger.warn('Feature flag ' + key + ' has been released')
+      logger.warn('Feature flag %s has been released', key)
     }
     if (feature_flag.unreleased.indexOf(key) > -1) {
-      logger.warn('Feature flag ' + key + ' has been deprecated')
+      logger.warn('Feature flag %s has been deprecated', key)
     }
   })
 }

package/lib/db/tracer.js

@@ -56,15 +56,15 @@ QueryTracer.prototype.addQuery = function addQuery(segment, type, query, trace)
 
   switch (this.config.transaction_tracer.record_sql) {
     case 'raw':
-      logger.info('recording raw sql')
+      logger.trace('recording raw sql')
       segment.parameters.sql = slowQuery.query
       break
     case 'obfuscated':
-      logger.info('recording obfuscated sql')
+      logger.trace('recording obfuscated sql')
       segment.parameters.sql_obfuscated = slowQuery.obfuscated
       break
     default:
-      logger.info(
+      logger.trace(
         'not collecting slow-query because transaction_tracer.record_sql was set to %s',
         this.config.transaction_tracer.record_sql
       )

package/lib/feature_flags.js

@@ -6,6 +6,7 @@ exports.prerelease = {
   custom_metrics: true,
   express5: false,
   synthetics: true,
+  await_support: false,
   native_metrics: true,
   promise_segments: false,
   reverse_naming_rules: false,

package/lib/instrumentation/core/async_hooks.js

@@ -0,0 +1,92 @@
+'use strict'
+
+var logger = require('../../logger').child({component: 'async_hooks'})
+var promInit = require('../promise')
+var semver = require('semver')
+
+module.exports = initialize
+
+/**
+ * The spec for the native `Promise` class.
+ */
+var STATIC_PROMISE_METHODS = ['accept', 'all', 'defer', 'race', 'reject', 'resolve']
+var NATIVE_PROMISE_SPEC = {
+  name: 'global',
+  constructor: 'Promise',
+  executor: true,
+  $proto: {
+    then: ['then', 'chain'],
+    catch: ['catch']
+  },
+  $static: {
+    $copy: STATIC_PROMISE_METHODS,
+    cast: STATIC_PROMISE_METHODS
+  }
+}
+
+function initialize(agent) {
+  var enableHooks = agent.config.checkAsyncHookStatus()
+  if (enableHooks && tryAsyncHooks(agent)) {
+    logger.debug('Using async_hooks.')
+  } else if (semver.satisfies(process.version, '>=0.12')) {
+    logger.debug('Using promise instrumentation.')
+    promInit(agent, global, NATIVE_PROMISE_SPEC)
+  }
+}
+
+function tryAsyncHooks(agent) {
+  var asyncHooks = null
+  try {
+    asyncHooks = require('async_hooks')
+  } catch (e) {
+    logger.info(e, 'Not using async_hooks module.')
+    return false
+  }
+
+  // this map is reused to track the segment that was active when
+  // the before callback is called to be replaced in the after callback
+  var segmentMap = new Map()
+  module.exports._segmentMap = segmentMap
+
+  asyncHooks.createHook({
+    init: function initHook(id, type) {
+      var transaction = agent.getTransaction()
+
+      if (!transaction || type !== 'PROMISE') {
+        return
+      }
+
+      segmentMap.set(id, agent.tracer.getSegment())
+    },
+
+    before: function beforeHook(id) {
+      var hookSegment = segmentMap.get(id)
+
+      if (!hookSegment) {
+        return
+      }
+
+      segmentMap.set(id, agent.tracer.getSegment())
+      agent.tracer.segment = hookSegment
+    },
+    after: function afterHook(id) {
+      var hookSegment = segmentMap.get(id)
+
+      // hookSegment is the segment that was active before the promise
+      // executed. If the promise is executing before a segment has been
+      // restored, hookSegment will be null and should be restored. Thus
+      // undefined is the only invalid value here.
+      if (hookSegment === undefined) {
+        return
+      }
+
+      segmentMap.set(id, agent.tracer.getSegment())
+      agent.tracer.segment = hookSegment
+    },
+    destroy: function destHook(id) {
+      segmentMap.delete(id)
+    }
+  }).enable()
+
+  return true
+}

package/lib/instrumentation/core/child_process.js

@@ -1,6 +1,7 @@
 'use strict'
 
 var wrap = require('../../shimmer').wrapMethod
+var isWrapped = require('../../shimmer').isWrapped
 
 module.exports = initialize
 
@@ -12,4 +13,38 @@ function initialize(agent, childProcess) {
   function wrapMethod(fn, method) {
     return agent.tracer.wrapFunctionLast('child_process.' + method, null, fn)
   }
+
+  var childProcessProto = childProcess && childProcess.ChildProcess
+  // ChildProcess is exposed on Node 4 and higher
+  if (childProcessProto) {
+    wrapChildProcessCls(childProcess.ChildProcess)
+  } else {
+    wrap(childProcess, 'childProcess', ['fork', 'spawn'], wrapSpawn)
+  }
+
+  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 wrapChildProcessCls(childProcessCls) {
+    if (!childProcessCls || !childProcessCls.prototype ||
+      isWrapped(childProcessCls.prototype.on)) {
+      return
+    }
+
+    wrap(
+      childProcessCls.prototype,
+      'childProcess.ChildProcess.prototype',
+      'on',
+      function wrapEmit(fn) {
+        return agent.tracer.wrapFunctionNoSegment(fn, ['on', 'addListener'])
+      }
+    )
+  }
 }

package/lib/instrumentation/core/globals.js

@@ -1,29 +1,11 @@
 'use strict'
 
+var asyncHookInstrumentation = require('./async_hooks')
 var events = require('events')
 var wrap = require('../../shimmer').wrapMethod
-var promInit = require('../promise')
-var semver = require('semver')
 
 module.exports = initialize
 
-/**
- * The spec for the native `Promise` class.
- */
-var STATIC_PROMISE_METHODS = ['accept', 'all', 'defer', 'race', 'reject', 'resolve']
-var NATIVE_PROMISE_SPEC = {
-  name: 'global',
-  constructor: 'Promise',
-  executor: true,
-  $proto: {
-    then: ['then', 'chain'],
-    catch: ['catch']
-  },
-  $static: {
-    $copy: STATIC_PROMISE_METHODS,
-    cast: STATIC_PROMISE_METHODS
-  }
-}
 
 function initialize(agent) {
   // `_fatalException` is an undocumented feature of domains, introduced in
@@ -63,10 +45,9 @@ function initialize(agent) {
     }
   )
 
-  // Promises don't exist prior to version 12
-  if (semver.satisfies(process.version, '>=0.12')) {
-    promInit(agent, global, NATIVE_PROMISE_SPEC)
-  }
+  // This will initialize the most optimal native-promise instrumentation
+  // that we have available.
+  asyncHookInstrumentation(agent)
 }
 
 function listenerCount(emitter, evnt) {

package/lib/instrumentation/core/http.js

@@ -131,7 +131,7 @@ function wrapEmitWithTransaction(agent, emit) {
       var start = parseFloat(qtime)
 
       if (isNaN(start)) {
-        logger.warn('Queue time header parsed as NaN (' + qtime + ')')
+        logger.warn('Queue time header parsed as NaN (%s)', qtime)
       } else {
         // nano seconds
         if (start > 1e18) start = start / 1e6

package/lib/instrumentation/hapi.js

@@ -23,6 +23,33 @@ module.exports = function initialize(agent, hapi, moduleName, shim) {
 }
 
 function wrapServer(shim, Server) {
+  // wrap server.handler function that registers a new handler type
+  // the second argument is expected to be a function that generates the handler function
+  shim.wrap(Server.prototype, 'handler', function wrapHandler(shim, original) {
+    return function wrappedHandler() {
+      var args = shim.argsToArray.apply(shim, arguments)
+
+      var handlerGenerator = args[1]
+      if (typeof handlerGenerator === 'function') {
+        args[1] = wrapGenerator(handlerGenerator)
+      }
+
+      return original.apply(this, args)
+
+      function wrapGenerator(generator) {
+        return function wrappedGenerator() {
+          var generatorArgs = shim.argsToArray.apply(shim, arguments)
+          var handler = generator.apply(this, generatorArgs)
+          if (typeof handler === 'function') {
+            var route = generatorArgs[0]
+            return wrapRouteHandler(shim, handler, route && route.path)
+          }
+          return handler
+        }
+      }
+    }
+  })
+
   shim.wrap(Server.prototype, 'route', function wrapRoute(shim, original) {
     return function wrappedRoute() {
       var args = shim.argsToArray.apply(shim, arguments)
@@ -35,44 +62,19 @@ function wrapServer(shim, Server) {
       var route = args[0]
       // handler function could be on the route object, or on a nested config object
       if (route.config) {
-        wrapRoute(shim, route.config, route.path)
+        _wrapRouteHandler(shim, route.config, route.path)
       } else {
-        wrapRoute(shim, route)
+        _wrapRouteHandler(shim, route)
       }
 
       return original.apply(this, args)
 
-      function wrapRoute(shim, route, path) {
-        shim.wrap(route, 'handler', function wrapHandler(shim, handler) {
-          var wrappedHandler = shim.wrap(handler, function wrapHandler(shim, original) {
-            return function wrappedHandler() {
-              var reply = arguments[1]
-              if (reply) {
-                shim.recordRender(reply, 'view')
-              }
-              return original.apply(this, arguments)
-            }
-          })
-
-          return shim.recordMiddleware(wrappedHandler, {
-            route: path || route.path,
-            req: function getReq(shim, fn, fnName, args) {
-              var request = args[0]
-              if (request && request.raw) {
-                return request.raw.req
-              }
-            },
-            next: function wrapNext(shim, fn, fnName, args, wrap) {
-              var reply = args[1]
-              if (!shim.isFunction(reply)) return
-              wrap(reply, 'response', true)
-            },
-            params: function getParams(shim, fn, fnName, args, req) {
-              var req = args[0]
-              if (!req) return
-              return req.params
-            }
-          })
+      function _wrapRouteHandler(shim, container, path) {
+        if (typeof container.handler !== 'function') {
+          return
+        }
+        shim.wrap(container, 'handler', function wrapHandler(shim, handler) {
+          return wrapRouteHandler(shim, handler, path || route.path)
         })
       }
     }
@@ -109,3 +111,35 @@ function wrapCreateServer(shim, hapi) {
     }
   })
 }
+
+function wrapRouteHandler(shim, handler, path) {
+  var wrappedHandler = shim.wrap(handler, function wrapHandler(shim, original) {
+    return function wrapped() {
+      var reply = arguments[1]
+      if (reply) {
+        shim.recordRender(reply, 'view')
+      }
+      return original.apply(this, arguments)
+    }
+  })
+
+  return shim.recordMiddleware(wrappedHandler, {
+    route: path,
+    req: function getReq(shim, fn, fnName, args) {
+      var request = args[0]
+      if (request && request.raw) {
+        return request.raw.req
+      }
+    },
+    next: function wrapNext(shim, fn, fnName, args, wrap) {
+      var reply = args[1]
+      if (!shim.isFunction(reply)) return
+      wrap(reply, 'response', true)
+    },
+    params: function getParams(shim, fn, fnName, args, req) {
+      var req = args[0]
+      if (!req) return
+      return req.params
+    }
+  })
+}

package/lib/metrics/names.js

@@ -150,7 +150,8 @@ var SUPPORTABILITY = {
   EVENTS: 'Supportability/Events',
   API: 'Supportability/API',
   UTILIZATION: 'Supportability/utilization',
-  DEPENDENCIES: 'Supportability/InstalledDependencies'
+  DEPENDENCIES: 'Supportability/InstalledDependencies',
+  NODEJS: 'Supportability/Nodejs'
 }
 
 var UTILIZATION = {

package/lib/shim/shim.js

@@ -127,6 +127,7 @@ Shim.prototype.record = record
 Shim.prototype.isWrapped = isWrapped
 Shim.prototype.unwrap = unwrap
 Shim.prototype.getSegment = getSegment
+Shim.prototype.getActiveSegment = getActiveSegment
 Shim.prototype.storeSegment = storeSegment
 Shim.prototype.bindCallbackSegment = bindCallbackSegment
 Shim.prototype.applySegment = applySegment
@@ -875,8 +876,8 @@ function record(nodule, properties, recordNamer) {
     shim.logger.trace('Wrapping "%s" with metric recording.', name)
 
     return function wrapper() {
-      // See if we're in a transaction.
-      var parent = shim.getSegment()
+      // See if we're in an active transaction.
+      var parent = shim.getActiveSegment()
       if (!parent) {
         shim.logger.debug('Not recording function %s, not in a transaction.', name)
         return fn.apply(this, arguments)
@@ -911,6 +912,9 @@ function record(nodule, properties, recordNamer) {
       })
 
       // Apply the function, and (if it returned a stream) bind that too.
+      // If you are looking here Geoff, the reason there is no check for
+      // `segment` is because it should be guaranteed by the parent and active
+      // transaction check at the beginning of this function. :)
       var ret = _applyRecorderSegment(segment, this, args, segDesc)
       if (ret) {
         if (segDesc.stream) {
@@ -1141,8 +1145,8 @@ function bindCallbackSegment(args, cbIdx, parentSegment) {
 }
 
 /**
- * Retrieves the segment associated with the given object, or the currently
- * active segment if no object is given.
+ * Retrieves the segment associated with the given object, or the current
+ * segment if no object is given.
  *
  * - `getSegment([obj])`
  *
@@ -1151,8 +1155,8 @@ function bindCallbackSegment(args, cbIdx, parentSegment) {
  * @param {*} [obj] - The object to retrieve a segment from.
  *
  * @return {?TraceSegment} The trace segment associated with the given object or
- *  the currently active segment if no object is provided or no segment is
- *  associated with the object.
+ *  the current segment if no object is provided or no segment is associated
+ *  with the object.
  */
 function getSegment(obj) {
   if (obj && obj.__NR_segment) {
@@ -1161,6 +1165,32 @@ function getSegment(obj) {
   return this.tracer.getSegment()
 }
 
+
+/**
+ * Retrieves the segment associated with the given object, or the currently
+ * active segment if no object is given.
+ *
+ * - `getActiveSegment([obj])`
+ *
+ * An active segment is one whose transaction is still active (e.g. has not
+ * ended yet).
+ *
+ * @memberof Shim.prototype
+ *
+ * @param {*} [obj] - The object to retrieve a segment from.
+ *
+ * @return {?TraceSegment} The trace segment associated with the given object or
+ *  the currently active segment if no object is provided or no segment is
+ *  associated with the object.
+ */
+function getActiveSegment(obj) {
+  var segment = this.getSegment(obj)
+  if (segment && segment.transaction && segment.transaction.isActive()) {
+    return segment
+  }
+  return null
+}
+
 /**
  * Associates a segment with the given object.
  *

package/lib/shim/webframework-shim.js

@@ -652,8 +652,10 @@ function setErrorPredicate(pred) {
  */
 function captureUrlParams(params) {
   var segment = this.getSegment()
-  var config = this.agent.config
-  urltils.copyParameters(config, params, segment.parameters)
+  if (segment) {
+    var config = this.agent.config
+    urltils.copyParameters(config, params, segment.parameters)
+  }
 }
 
 // -------------------------------------------------------------------------- //

package/lib/stats/index.js

@@ -41,7 +41,7 @@ Stats.prototype.recordValue = function recordValue(totalTime, exclusiveTime) {
   this.max = Math.max(totalTime, this.max)
 
   this.sumOfSquares += (totalTime * totalTime)
-  this.callCount += 1
+  ++this.callCount
   this.total += totalTime
   this.totalExclusive += exclusiveTime
 }

package/lib/system-info.js

@@ -142,7 +142,7 @@ module.exports._getProcessorStats = function getProcessorStats(callback) {
       callback(parseCpuInfo(data))
     })
   } else {
-    logger.debug('Unknown platform: ' + platform + ', could not retrieve processor info')
+    logger.debug('Unknown platform: %s; could not retrieve processor info', platform)
     callback(processorStats)
   }
 }
@@ -162,7 +162,7 @@ module.exports._getMemoryStats = function getMemoryStats(callback) {
       callback(parseMemInfo(data))
     })
   } else {
-    logger.debug('Unknown platform: ' + platform + ', could not retrieve memory info')
+    logger.debug('Unknown platform: %s; could not retrieve memory info', platform)
     callback(null)
   }
 }
@@ -181,7 +181,7 @@ function getKernelVersion(callback) {
       callback(data)
     })
   } else {
-    logger.debug('Unknown platform' + platform + ', could not read kernel version')
+    logger.debug('Unknown platform: %s; could not read kernel version', platform)
     callback(null)
   }
 }
@@ -196,7 +196,7 @@ function getSysctlValue(names, callback) {
     function respond(err, stdout, stderr) {
       if (returned) return
       if (err) {
-        logger.debug('Error when trying to run: sysctl -n ' + name + ': %s', err.message)
+        logger.debug('Error when trying to run: sysctl -n %s: %s', name, err.message)
         callback(null)
         returned = true
       } else if (!stderr) {
@@ -204,7 +204,7 @@ function getSysctlValue(names, callback) {
         returned = true
       }
       if (++ran === names.length && !returned) {
-        logger.debug('No sysctl info found for names: ' + names.toString())
+        logger.debug('No sysctl info found for names: %j', names)
         callback(null)
       }
     }

package/lib/transaction/index.js

@@ -53,7 +53,8 @@ function Transaction(agent) {
     agent.metricNameNormalizer
   )
 
-  agent.activeTransactions++
+  ++agent.activeTransactions
+  ++agent.transactionCreatedInHarvest
 
   this.numSegments = 0
 
@@ -144,8 +145,9 @@ Transaction.prototype.end = function end(done) {
     )
   }
 
-  var transaction = this
+  this.agent.recordSupportability('Transactions/Segments', this.numSegments)
 
+  var transaction = this
   transaction.trace.end()
   process.nextTick(function nextTickedEnd() {
     // recorders must be run before the trace is collected
@@ -404,6 +406,12 @@ function finalizeNameFromUri(requestURL, statusCode) {
  *  the current partial name is used.
  */
 Transaction.prototype.finalizeName = function finalizeName(name) {
+  // If no name is given, and this is a web transaction with a url, then
+  // finalize the name using the stored url.
+  if (name == null && this.type === 'web' && this.url) {
+    return this.finalizeNameFromUri(this.url, this.statusCode)
+  }
+
   this._partialName = name || this._partialName
 
   var fullName = TYPE_METRICS[this.type] + '/' + this._partialName

package/lib/transaction/tracer/index.js

@@ -100,6 +100,7 @@ function transactionProxy(handler) {
         transaction: {id: segment.transaction.id, name: segment.transaction.getName()},
         segment: segment.name
       }, 'Active transaction when creating non-nested transaction')
+      tracer.agent.recordSupportability('Transactions/Nested')
       return handler.apply(this, arguments)
     }
     var transaction = new Transaction(tracer.agent)

package/lib/util/logger.js

@@ -129,12 +129,12 @@ Logger.prototype.child = function child(extra) {
   var parent = this
   childLogger.options = parent.options
 
-  childLogger.write = function write(level, args, extra) {
-    extra = getPropertiesToLog(extra)
+  childLogger.write = function write(level, args, _extra) {
+    _extra = getPropertiesToLog(_extra)
     var selfExtra = util._extend({}, this.extra)
 
-    extra = util._extend(selfExtra, extra)
-    return parent.write(level, args, extra)
+    _extra = util._extend(selfExtra, _extra)
+    return parent.write(level, args, _extra)
   }
 
   childLogger.setEnabled = Logger.prototype.setEnabled

package/lib/utilization/common.js

@@ -97,7 +97,7 @@ exports.readProc = readProc
 function readProc(path, callback) {
   fs.readFile(path, function readProcFile(err, data) {
     if (err) {
-      logger.error('Error when trying to read ' + path, err)
+      logger.error(err, 'Error when trying to read %s', path)
       callback(err, null)
     } else {
       callback(null, data.toString())

package/newrelic.js

@@ -1,9 +1,8 @@
 'use strict'
-
 /**
  * New Relic agent configuration.
  *
- * See lib/config.default.js in the agent distribution for a more complete
+ * See lib/config.defaults.js in the agent distribution for a more complete
  * description of configuration variables and their potential values.
  */
 exports.config = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "licenses": [
     {
@@ -115,6 +115,7 @@
   },
   "devDependencies": {
     "async": "^2.1.4",
+    "benchmark": "^2.1.4",
     "bluebird": "^3.4.7",
     "eslint": "^2.9.0",
     "jsdoc": "^3.4.0",

package/stub_api.js

@@ -3,13 +3,16 @@
 var logger = require('./lib/logger.js')
 var RealAPI = require('./api.js')
 var TransactionHandle = require('./lib/transaction/handle')
+var util = require('util')
 
 
 /* eslint-disable no-eval */
 function stubFunction(name) {
-  return eval("(function () {return function " + name + "() {" +
-              "logger.debug('Not calling " + name + " because New Relic is disabled.');" +
-              "}}())")
+  return eval(
+    "(function () {return function " + name + "() {" +
+    "logger.debug('Not calling " + name + " because New Relic is disabled.');" +
+    "}}())"
+  )
 }
 /* eslint-enable no-eval */
 
@@ -28,8 +31,22 @@ for (var i = 0; i < length; i++) {
 }
 
 Stub.prototype.createTracer = createTracer
-Stub.prototype.createWebTransaction = createWebTransaction
-Stub.prototype.createBackgroundTransaction = createBackgroundTransaction
+Stub.prototype.createWebTransaction = util.deprecate(
+  createWebTransaction, [
+    'API#createWebTransaction is being deprecated!',
+    'Please use API#startWebTransaction for transaction creation',
+    'and API#getTransaction for transaction management including',
+    'ending transactions.'
+  ].join(' ')
+)
+Stub.prototype.createBackgroundTransaction = util.deprecate(
+  createBackgroundTransaction, [
+    'API#createBackgroundTransaction is being deprecated!',
+    'Please use API#startBackgroundTransaction for transaction creation',
+    'and API#getTransaction for transaction management including',
+    'ending transactions.'
+  ].join(' ')
+)
 Stub.prototype.startWebTransaction = startWebTransaction
 Stub.prototype.startBackgroundTransaction = startBackgroundTransaction
 Stub.prototype.getTransaction = getTransaction
@@ -89,17 +106,17 @@ function startBackgroundTransaction(name, group, callback) {
 // Normally the following call executes callback asynchronously
 function shutdown(options, cb) {
   logger.debug('Not calling shutdown because New Relic is disabled.')
-  
+
   var callback = cb
   if (!callback) {
     if (typeof options === 'function') {
       callback = options
     } else {
-      callback = new Function()
+      callback = function __NR_defaultCb() {}
     }
   }
-  
-  process.nextTick(callback)
+
+  setImmediate(callback)
 }
 
 module.exports = Stub