newrelic 3.1.0 → 4.0.0

package/.travis.yml

@@ -1,7 +1,5 @@
 language: node_js
 node_js:
-  - "0.10"
-  - "0.12"
   - "4"
   - "5"
   - "6"
@@ -18,14 +16,6 @@ env:
   - SUITE=versioned
 matrix:
   exclude:
-    - node_js: "0.10"
-      env: SUITE=security
-    - node_js: "0.10"
-      env: SUITE=lint
-    - node_js: "0.12"
-      env: SUITE=security
-    - node_js: "0.12"
-      env: SUITE=lint
     - node_js: "4"
       env: SUITE=security
     - node_js: "4"

package/Migration Guide.md

@@ -3,6 +3,18 @@
 This guide is intended to help with upgrading major versions of the Node Agent.
 This information can also be found on [our documentation website][upgrade-doc].
 
+## Upgrading to Agent v4
+
+### Breaking Changes
+
+**Upgraded https-proxy-agent from v0 to v2**: This dependency has been updated
+due to a security issue in the version of `https-proxy-agent` the New Relic Node.js
+agent used. `https-proxy` v2 is incompatible with node v0.10 and v0.12,
+requiring deprecation of those versions for the agent. There is no required
+action to migrate from v3 to v4 of New Relic's Node.js agent.
+
+--------------------------------------------------------------------------------
+
 ## Upgrading to Agent v3
 
 ### Breaking Changes

package/NEWS.md

@@ -1,3 +1,68 @@
+### 4.0.0 (2018-04-12):
+
+* BREAKING: Updated the version of `https-proxy-agent` to v2.x - Dropped support for v0.10 and v0.12 of node.
+
+  The version of `https-proxy-agent` used in the agent has a known security
+  issue you can read about here: https://snyk.io/vuln/npm:https-proxy-agent:20180402
+  In order to resolve this issue, the dependency had to be updated to at least
+  v2.2.0, which only supported node versions >=4.  The update to this dependency
+  forces the incompatibility of the agent with versions 0.10 and 0.12 of node.
+
+  In order to use use the Node.js agent, please upgrade node to version >=4, or you can
+  continue to use the agent on node versions 0.10 and 0.12 by pinning the agent
+  to v3.
+
+  You can read more about the issue here: https://docs.newrelic.com/docs/using-new-relic/new-relic-security/security-bulletins/security-bulletin-nr18-08
+
+### 3.3.1 (2018-04-10):
+
+* Added a type check to attribute validation, restricting values to primitive types
+  (but not `undefined`).
+
+  Previously the agent was only enforcing byte limits on string values, resulting
+  in overly large arrays being collected. This brings the agent in line with other
+  language agents.
+
+* The `DatastoreShim` will now respect specified `after` handlers.
+
+  Previously on methods like `DatastoreShim#recordQuery` the `after` handler would
+  be dropped. The property is now correctly propagated to the underlying
+  `Shim#record` call.
+
+* The agent will now check that a specified parent segment is part of an active
+  segment before running a method under instrumentation.
+
+  Previously the agent would unconditionally run a method under a specified
+  parent. The shim expects the parent to exist and be active, and will throw
+  errors in the case where the parent belongs to an inactive transaction.
+
+### 3.3.0 (2018-03-27):
+
+* Added `newrelic.startSegment()` which replaces `newrelic.createTracer()`.
+
+  This new API method allows you to create custom segments using either callbacks
+  or promises.
+
+* Fixed bug in `pre` route config option in Hapi instrumentation.
+
+  Only applies to Hapi v16 and below. The `pre` handler wrapping was not properly
+  returning in cases when the element was a string referring to a registered server
+  method, and as a result these elements would be replaced with `undefined`.
+
+### 3.2.0 (2018-03-14):
+
+* Added [`@newrelic/koa`](https://github.com/newrelic/node-newrelic-koa) as a
+  dependency.
+
+  This introduces instrumentation for **Koa v2.0.0** or higher. It will be treated
+  as first-party instrumentation within the agent, but publishing it as a
+  separate module allows it to be installed independently according to users' needs.
+
+* Refactored instrumentation hooks to work with modules.
+
+  With this change it is now possible to link against external instrumentation
+  modules.
+
 ### 3.1.0 (2018-03-13):
 
 * Promise based web framework middleware instrumentation now supports callback

package/README.md

@@ -708,15 +708,17 @@ 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)
+#### newrelic.startSegment(name, record, handler, callback)
 
-`name` is the name of the tracer. It will show up as a segment in your
-transaction traces and create its own metric. `handle` is the function to be
-bound to the tracer.
+`name` is the name of the segment. `record` is a boolean value signalling
+whether or not to record the segment as a metric. `handler` is the function
+being recorded. `callback` is an optional function that is passed to the
+handler and fired after all other work is complete.
 
-Timing is from when `createTracer` is called until the `handle` done executing.
-This should be called inside of a transaction to get data. If it is called
-outside of a transaction it will just pass through.
+Timing is from when `startSegment` is called until the `handler` is done
+executing, or when the `callback` is fired, if it's supplied. This method
+should be called inside of a transaction to get data. If it is called outside
+of a transaction it will just pass through.
 
 #### newrelic.recordMetric(name, value)
 

package/api.js

@@ -629,13 +629,23 @@ API.prototype.getBrowserTimingHeader = function getBrowserTimingHeader() {
   return out
 }
 
+API.prototype.createTracer = util.deprecate(
+  createTracer, [
+    'API#createTracer is being deprecated!',
+    'Please use API#startSegment for segment creation.'
+  ].join(' ')
+)
+
 /**
  * This creates a new tracer with the passed in name. It then wraps the
  * callback and binds it to the current transaction and segment so any further
  * custom instrumentation as well as auto instrumentation will also be able to
  * find the current transaction and segment.
+ *
+ * @memberof API#
+ * @deprecated use {@link API#startSegment} instead
  */
-API.prototype.createTracer = function createTracer(name, callback) {
+function createTracer(name, callback) {
   var metric = this.agent.metrics.getOrCreateMetric(
     NAMES.SUPPORTABILITY.API + '/createTracer'
   )
@@ -687,6 +697,70 @@ API.prototype.createTracer = function createTracer(name, callback) {
   return arity.fixArity(callback, tracer.bindFunction(callback, segment, true))
 }
 
+/**
+ * Wraps the given handler in a segment which may optionally be turned into a
+ * metric.
+ *
+ * @example
+ *  newrelic.startSegment('mySegment', false, function handler() {
+ *    // The returned promise here will signify the end of the segment.
+ *    return myAsyncTask().then(myNextTask)
+ *  })
+ *
+ * @param {string} name
+ *  The name to give the new segment. This will also be the name of the metric.
+ *
+ * @param {bool} record
+ *  Indicates if the segment should be recorded as a metric. Metrics will show
+ *  up on the transaction breakdown table and server breakdown graph. Segments
+ *  just show up in transaction traces.
+ *
+ * @param {function(cb) -> ?Promise} handler
+ *  The function to track as a segment.
+ *
+ * @param {function} [callback]
+ *  An optional callback for the handler. This will indicate the end of the
+ *  timing if provided.
+ *
+ * @return {*} Returns the result of calling `handler`.
+ */
+API.prototype.startSegment = function startSegment(name, record, handler, callback) {
+  this.agent.metrics.getOrCreateMetric(
+    NAMES.SUPPORTABILITY.API + '/startSegment'
+  ).incrementCallCount()
+
+  // Check that we have usable arguments.
+  if (!name || typeof handler !== 'function') {
+    logger.warn('Name and handler function are both required for startSegment')
+    if (typeof handler === 'function') {
+      return handler(callback)
+    }
+    return
+  }
+  if (callback && typeof callback !== 'function') {
+    logger.warn('If using callback, it must be a function')
+    return handler(callback)
+  }
+
+  // Are we inside a transaction?
+  if (!this.shim.getActiveSegment()) {
+    logger.debug('startSegment(%j) called outside of a transaction, not recording.', name)
+    return handler(callback)
+  }
+
+  // Create the segment and call the handler.
+  var wrappedHandler = this.shim.record(handler, function handlerNamer(shim) {
+    return {
+      name: name,
+      recorder: record ? customRecorder : null,
+      callback: callback ? shim.FIRST : null,
+      promise: !callback
+    }
+  })
+
+  return wrappedHandler(callback)
+}
+
 API.prototype.createWebTransaction = util.deprecate(
   createWebTransaction, [
     'API#createWebTransaction is being deprecated!',
@@ -713,7 +787,7 @@ API.prototype.createWebTransaction = util.deprecate(
                                 name and not iclude any variable parameters.
  * @param {Function}  handle    Function that represents the transaction work.
  *
- * @memberOf API#
+ * @memberof API#
  *
  * @deprecated since version 2.0
  */

package/bin/run-versioned-tests.sh

@@ -9,10 +9,13 @@ fi
 # fi
 
 set -f
-DIRECTORY="test/versioned/**/*.tap.js"
+directories=()
 if [[ "$1" != '' ]]; then
-  DIRECTORY="test/versioned/${1}/*.tap.js"
+  directories=(
+    "test/versioned/${1}"
+    "node_modules/@newrelic/${1}/tests/versioned"
+  )
 fi
 
-export NEW_RELIC_HOME=`pwd`/test/versioned
-time ./node_modules/.bin/versioned-tests $VERSIONED_MODE -i 2 $DIRECTORY
+export AGENT_PATH=`pwd`
+time ./node_modules/.bin/versioned-tests $VERSIONED_MODE -i 2 ${directories[@]}

package/index.js

@@ -42,10 +42,10 @@ function initialize() {
       preAgentTime
     )
 
-    // TODO: Update this check when Node v0.10 is deprecated.
-    if (psemver.satisfies('<0.10.0')) {
+    // TODO: Update this check when Node v4 is deprecated.
+    if (psemver.satisfies('<4.0.0')) {
       message = "New Relic for Node.js requires a version of Node equal to or\n" +
-                "greater than 0.10.0. Not starting!"
+                "greater than 4.0.0. Not starting!"
 
       logger.error(message)
       throw new Error(message)

package/lib/instrumentation/core/http.js

@@ -633,7 +633,12 @@ module.exports = function initialize(agent, http, moduleName) {
       wrapRequest.bind(null, agent)
     )
 
-    if (psemver.satisfies('>=8')) {
+    // Upon updating to https-proxy-agent v2, we are now using
+    // agent-base v4, which patches https.get to use https.request.
+    // https://github.com/TooTallNate/node-agent-base/commit/7de92df780e147d46185281d26a1b534b3aaa97e
+    // This means we need to skip instrumenting to avoid double
+    // instrumenting external requests.
+    if (moduleName !== 'https' && psemver.satisfies('>=8')) {
       shimmer.wrapMethod(
         http,
         'http',

package/lib/instrumentation/hapi.js

@@ -146,6 +146,10 @@ function wrapPreHandlers(shim, container, path) {
       return _wrapPreHandler(handler)
     })
   }
+  // The 'pre' option also allows strings pointing to methods registered via
+  // server.method() (ie: 'methodName(args)'). For the most part, these should
+  // be simple utility functions, but may be something we want to wrap in the future.
+  return container
 
   function _wrapPreHandler(handler) {
     return shim.recordMiddleware(

package/lib/instrumentations.js

@@ -1,26 +1,30 @@
 'use strict'
 
+var MODULE_TYPE = require('./shim/constants').MODULE_TYPE
+
 // Return a new copy of this array every time we're called
 module.exports = function instrumentations() {
-  return [
-    'connect',
-    'bluebird',
-    'director',
-    'express',
-    'generic-pool',
-    'hapi',
-    'ioredis',
-    'memcached',
-    'mongodb',
-    'mysql',
-    'node-cassandra-cql',
-    'cassandra-driver',
-    'pg',
-    'q',
-    'redis',
-    'restify',
-    'oracle',
-    'vision',
-    'when'
-  ]
+  return {
+    'amqplib': {type: MODULE_TYPE.MESSAGE},
+    'connect': {type: MODULE_TYPE.WEB_FRAMEWORK},
+    'bluebird': {type: null},
+    'director': {type: MODULE_TYPE.WEB_FRAMEWORK},
+    'express': {type: MODULE_TYPE.WEB_FRAMEWORK},
+    'generic-pool': {type: MODULE_TYPE.GENERIC},
+    'hapi': {type: MODULE_TYPE.WEB_FRAMEWORK},
+    'ioredis': {type: MODULE_TYPE.DATASTORE},
+    'koa': {module: '@newrelic/koa'},
+    'memcached': {type: MODULE_TYPE.DATASTORE},
+    'mongodb': {type: MODULE_TYPE.DATASTORE},
+    'mysql': {type: MODULE_TYPE.DATASTORE},
+    'node-cassandra-cql': {type: MODULE_TYPE.DATASTORE},
+    'cassandra-driver': {type: MODULE_TYPE.DATASTORE},
+    'pg': {type: MODULE_TYPE.DATASTORE},
+    'q': {type: null},
+    'redis': {type: MODULE_TYPE.DATASTORE},
+    'restify': {type: MODULE_TYPE.WEB_FRAMEWORK},
+    'oracle': {type: null},
+    'vision': {type: MODULE_TYPE.WEB_FRAMEWORK},
+    'when': {type: null}
+  }
 }

package/lib/shim/datastore-shim.js

@@ -408,6 +408,7 @@ function recordOperation(nodule, properties, opSpec) {
         name: opSpec.name || fnName || 'other',
         parameters: opSpec.parameters,
         callback: opSpec.callback,
+        after: 'after' in opSpec ? opSpec.after : null,
         promise: 'promise' in opSpec ? opSpec.promise : null,
         record: opSpec.record
       }
@@ -716,6 +717,7 @@ function _recordQuery(suffix, nodule, properties, querySpec) {
         callback:     'callback'    in queryDesc ? queryDesc.callback : null,
         rowCallback:  'rowCallback' in queryDesc ? queryDesc.rowCallback : null,
         stream:       'stream'      in queryDesc ? queryDesc.stream : null,
+        after:        'after'       in queryDesc ? queryDesc.after : null,
         promise:      'promise'     in queryDesc ? queryDesc.promise : null,
         internal:     'internal'    in queryDesc ? queryDesc.internal : false,
         opaque:       'opaque'      in queryDesc ? queryDesc.opaque : false
@@ -742,6 +744,7 @@ function _recordQuery(suffix, nodule, properties, querySpec) {
       callback:     'callback'    in queryDesc ? queryDesc.callback : null,
       rowCallback:  'rowCallback' in queryDesc ? queryDesc.rowCallback : null,
       stream:       'stream'      in queryDesc ? queryDesc.stream : null,
+      after:        'after'       in queryDesc ? queryDesc.after : null,
       promise:      'promise'     in queryDesc ? queryDesc.promise : null,
       internal:     'internal'    in queryDesc ? queryDesc.internal : true,
       opaque:       'opaque'      in queryDesc ? queryDesc.opaque : false,

package/lib/shim/shim.js

@@ -887,7 +887,15 @@ function record(nodule, properties, recordNamer) {
       segDesc = new specs.RecorderSpec(segDesc)
 
       // See if we're in an active transaction.
-      var parent = segDesc.parent || shim.getActiveSegment()
+      var parent
+      if (segDesc.parent) {
+        // We only want to continue recording in a transaction if the
+        // transaction is active.
+        parent = segDesc.parent.transaction.isActive() ? segDesc.parent : null
+      } else {
+        parent = shim.getActiveSegment()
+      }
+
       if (!parent) {
         shim.logger.debug('Not recording function %s, not in a transaction.', name)
         return fn.apply(this, arguments)

package/lib/shimmer.js

@@ -3,7 +3,7 @@
 var path = require('path')
 var fs = require('./util/unwrapped-core').fs
 var logger = require('./logger').child({component: 'shimmer'})
-var INSTRUMENTATION = require('./instrumentations')()
+var INSTRUMENTATIONS = require('./instrumentations')()
 var properties = require('./util/properties')
 var shims = require('./shim')
 
@@ -32,26 +32,6 @@ var MODULE_TYPE = shims.constants.MODULE_TYPE
 
 var registeredInstrumentations = Object.create(null)
 
-// TODO: is there a better way to do this?
-var instrumentationTypes = {
-  'amqplib': MODULE_TYPE.MESSAGE,
-  'generic-pool': MODULE_TYPE.GENERIC,
-  'ioredis': MODULE_TYPE.DATASTORE,
-  'mongodb': MODULE_TYPE.DATASTORE,
-  'mysql': MODULE_TYPE.DATASTORE,
-  'redis': MODULE_TYPE.DATASTORE,
-  'memcached': MODULE_TYPE.DATASTORE,
-  'pg': MODULE_TYPE.DATASTORE,
-  'cassandra-driver': MODULE_TYPE.DATASTORE,
-  'node-cassandra-cql': MODULE_TYPE.DATASTORE,
-  'connect': MODULE_TYPE.WEB_FRAMEWORK,
-  'express': MODULE_TYPE.WEB_FRAMEWORK,
-  'restify': MODULE_TYPE.WEB_FRAMEWORK,
-  'director': MODULE_TYPE.WEB_FRAMEWORK,
-  'hapi': MODULE_TYPE.WEB_FRAMEWORK,
-  'vision': MODULE_TYPE.WEB_FRAMEWORK
-}
-
 var SHIM_TYPE_MAP = Object.create(null)
 SHIM_TYPE_MAP[MODULE_TYPE.GENERIC] = shims.Shim
 SHIM_TYPE_MAP[MODULE_TYPE.DATASTORE] = shims.DatastoreShim
@@ -380,18 +360,24 @@ var shimmer = module.exports = {
     })
 
     // Register all the first-party instrumentations.
-    INSTRUMENTATION.forEach(function forEachInstrumentation(moduleName) {
-      var fileName = path.join(__dirname, 'instrumentation', moduleName + '.js')
-      shimmer.registerInstrumentation({
-        moduleName: moduleName,
-        type: instrumentationTypes[moduleName],
-        onRequire: _firstPartyInstrumentation.bind(null, agent, fileName)
-      })
+    Object.keys(INSTRUMENTATIONS).forEach(function forEachInstrumentation(moduleName) {
+      var instrInfo = INSTRUMENTATIONS[moduleName]
+      if (instrInfo.module) {
+        var hooks = require(instrInfo.module + '/nr-hooks')
+        hooks.forEach(shimmer.registerInstrumentation)
+      } else if (moduleName === 'amqplib') {
+        // TODO: Remove this code when amqplib instrumentation is made external.
+        require('./instrumentation/amqplib').selfRegister(shimmer)
+      } else {
+        var fileName = path.join(__dirname, 'instrumentation', moduleName + '.js')
+        shimmer.registerInstrumentation({
+          moduleName: moduleName,
+          type: instrInfo.type,
+          onRequire: _firstPartyInstrumentation.bind(null, agent, fileName)
+        })
+      }
     })
 
-    // TODO: Remove this code when amqplib instrumentation is made external.
-    require('./instrumentation/amqplib').selfRegister(shimmer)
-
     // Even though domain is a core module we add it as a registered
     // instrumentation to be lazy-loaded because we do not want to cause domain
     // usage.

package/lib/transaction/trace/attributes.js

@@ -51,7 +51,7 @@ TraceAttributes.prototype.get = function get(dest) {
   var attrCount = 0
   for (var key in this.attributes) { // eslint-disable-line guard-for-in
     var attr = this.attributes[key]
-    if (!(attr.destinations & dest)) {
+    if (!(attr.destinations & dest) || !isValidType(attr.value)) {
       continue
     }
 
@@ -98,3 +98,15 @@ function truncate(val) {
   }
   return val
 }
+
+/**
+ * Checks incoming attribute value against valid types:
+ * string, number, boolean, & null.
+ *
+ * @param {*} val
+ *
+ * @return {boolean}
+ */
+function isValidType(val) {
+  return val === null || typeof val !== 'object' && val !== undefined
+}

package/lib/uninstrumented.js

@@ -3,10 +3,16 @@
 var path = require('path')
 var logger = require('./logger')
 var NAMES = require('./metrics/names')
-var INSTRUMENTATIONS = require('./instrumentations')()
+var INSTRUMENTATIONS = Object.keys(require('./instrumentations')())
 var properties = require('./util/properties')
 
 
+// TODO: This should iterate over the registered instrumentations in the shimmer.
+//  As long as this file is executed after `bootstrapInstrumentation` is called
+//  the shimmer should have a complete list of all instrumentation names we
+//  hook into.
+
+
 module.exports = {
   check: check,
   createMetrics: createMetrics

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "licenses": [
     {
@@ -96,7 +96,7 @@
   ],
   "homepage": "http://github.com/newrelic/node-newrelic",
   "engines": {
-    "node": ">=0.10.0",
+    "node": ">=4.0.0",
     "npm": ">=2.0.0"
   },
   "directories": {
@@ -111,9 +111,10 @@
     "newrelic-naming-rules": "./bin/test-naming-rules.js"
   },
   "dependencies": {
+    "@newrelic/koa": "^1.0.0",
     "async": "^2.1.4",
     "concat-stream": "^1.5.0",
-    "https-proxy-agent": "^0.3.6",
+    "https-proxy-agent": "^2.2.1",
     "json-stringify-safe": "^5.0.0",
     "readable-stream": "^2.1.4",
     "semver": "^5.3.0"
@@ -122,7 +123,7 @@
     "@newrelic/native-metrics": "^2.1.0"
   },
   "devDependencies": {
-    "@newrelic/test-utilities": "git+https://github.com/newrelic/node-test-utilities.git",
+    "@newrelic/test-utilities": "^1.2.0",
     "JSV": "~4.0.2",
     "architect": "*",
     "benchmark": "^2.1.4",
@@ -140,6 +141,7 @@
     "jsdoc": "^3.4.0",
     "lodash": "^4.17.5",
     "memcached": ">=0.2.8",
+    "methods": "^1.1.2",
     "minami": "^1.1.1",
     "mkdirp": "*",
     "mocha": "^3.5.3",

package/stub_api.js

@@ -30,7 +30,12 @@ for (var i = 0; i < length; i++) {
   Stub.prototype[functionName] = stubFunction(functionName)
 }
 
-Stub.prototype.createTracer = createTracer
+Stub.prototype.createTracer = util.deprecate(
+  createTracer, [
+    'API#createTracer is being deprecated!',
+    'Please use API#startSegment for segment creation.'
+  ].join(' ')
+)
 Stub.prototype.createWebTransaction = util.deprecate(
   createWebTransaction, [
     'API#createWebTransaction is being deprecated!',
@@ -47,6 +52,7 @@ Stub.prototype.createBackgroundTransaction = util.deprecate(
     'ending transactions.'
   ].join(' ')
 )
+Stub.prototype.startSegment = startSegment
 Stub.prototype.startWebTransaction = startWebTransaction
 Stub.prototype.startBackgroundTransaction = startBackgroundTransaction
 Stub.prototype.getTransaction = getTransaction
@@ -81,6 +87,14 @@ function createBackgroundTransaction(name, group, callback) {
   return (callback === undefined) ? group : callback
 }
 
+function startSegment(name, record, handler, callback) {
+  logger.debug('Not calling `startSegment` becuase New Relic is disabled.')
+  if (typeof handler === 'function') {
+    return handler(callback)
+  }
+  return null
+}
+
 function startWebTransaction(url, callback) {
   logger.debug('Not calling startWebTransaction because New Relic is disabled.')
   if (typeof callback === 'function') {