newrelic 2.0.0 → 2.2.0

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
 
@@ -77,6 +78,9 @@ var ENV_MAPPING = {
   },
   utilization: {
     detect_aws: "NEW_RELIC_UTILIZATION_DETECT_AWS",
+    detect_pcf: "NEW_RELIC_UTILIZATION_DETECT_PCF",
+    detect_azure: "NEW_RELIC_UTILIZATION_DETECT_AZURE",
+    detect_gcp: "NEW_RELIC_UTILIZATION_DETECT_GCP",
     detect_docker: "NEW_RELIC_UTILIZATION_DETECT_DOCKER",
     logical_processors: "NEW_RELIC_UTILIZATION_LOGICAL_PROCESSORS",
     total_ram_mib: "NEW_RELIC_UTILIZATION_TOTAL_RAM_MIB",
@@ -724,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.
  *
@@ -945,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',
@@ -1017,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/parse-sql.js

@@ -1,5 +1,8 @@
 'use strict'
 
+// TODO: remove in favor of /lib/db/query-parsers/sql.js
+// This module is currently used only in the Oracle instrumentation
+
 var logger = require('../logger').child({component: 'parse_sql'})
 var StatementMatcher = require('./statement-matcher')
 var ParsedStatement = require('./parsed-statement')

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/instrumentation/ioredis.js

@@ -33,12 +33,7 @@ module.exports = function initialize(agent, redis, moduleName, shim) {
     return {
       name: (command.name || 'unknown'),
       parameters: parameters,
-      callback: function bindCallback(shim, _f, _n, segment) {
-        // record duration when promise resolves
-        command.promise.finally(function cb_resolved() {
-          segment.touch()
-        })
-      }
+      promise: true
     }
   }
 }

package/lib/metrics/names.js

@@ -150,12 +150,17 @@ var SUPPORTABILITY = {
   EVENTS: 'Supportability/Events',
   API: 'Supportability/API',
   UTILIZATION: 'Supportability/utilization',
-  DEPENDENCIES: 'Supportability/InstalledDependencies'
+  DEPENDENCIES: 'Supportability/InstalledDependencies',
+  NODEJS: 'Supportability/Nodejs'
 }
 
 var UTILIZATION = {
   AWS_ERROR: SUPPORTABILITY.UTILIZATION + '/aws/error',
-  DOCKER_ERROR: SUPPORTABILITY.UTILIZATION + '/docker/error'
+  PCF_ERROR: SUPPORTABILITY.UTILIZATION + '/pcf/error',
+  AZURE_ERROR: SUPPORTABILITY.UTILIZATION + '/azure/error',
+  GCP_ERROR: SUPPORTABILITY.UTILIZATION + '/gcp/error',
+  DOCKER_ERROR: SUPPORTABILITY.UTILIZATION + '/docker/error',
+  BOOT_ID_ERROR: SUPPORTABILITY.UTILIZATION + '/boot_id/error'
 }
 
 

package/lib/shim/datastore-shim.js

@@ -523,10 +523,22 @@ function recordBatchQuery(nodule, properties, querySpec) {
  */
 function parseQuery(query, nodule) {
   var parsed = this.queryParser.call(nodule, query)
+
+  var collection = parsed.collection
+  // strip enclosing special characters from collection (table) name
+  if (typeof collection === 'string' && collection.length > 2) {
+    if (/^[\[{'"`]/.test(collection)) {
+      collection = collection.substr(1)
+    }
+    if (/[\]}'"`]$/.test(collection)) {
+      collection = collection.substr(0, collection.length - 1)
+    }
+  }
+
   return new ParsedStatement(
     this._metrics.PREFIX,
     parsed.operation,
-    parsed.collection,
+    collection,
     parsed.query
   )
 }

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,8 +912,11 @@ 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 (segment && ret) {
+      if (ret) {
         if (segDesc.stream) {
           shim.logger.trace('Binding return value as stream.')
           _bindStream(shim, ret, segment, {
@@ -1034,12 +1038,20 @@ function bindSegment(nodule, property, segment, full) {
 
   // Determine our arguments.
   if (this.isObject(property) && !this.isArray(property)) {
-    // bindSegment(func, segment, full)
+    // bindSegment(func, segment [, full])
     full = segment
     segment = property
     property = null
   }
 
+  // This protects against the `bindSegment(func, null, true)` case, where the
+  // segment is `null`, and thus `true` (the full param) is detected as the
+  // segment.
+  if (segment != null && !this.isObject(segment)) {
+    this.logger.debug({segment: segment}, 'Segment is not a segment, not binding.')
+    return nodule
+  }
+
   var wrapped = this.wrap(nodule, property, function wrapFunc(shim, func) {
     if (!shim.isFunction(func)) {
       return func
@@ -1133,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])`
  *
@@ -1143,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) {
@@ -1153,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
 }