newrelic 4.5.0 → 4.8.0

package/lib/db/tracer.js

@@ -46,27 +46,36 @@ QueryTracer.prototype.merge = function merge(tracer) {
 
 QueryTracer.prototype.addQuery = function addQuery(segment, type, query, trace) {
   const ttConfig = this.config.transaction_tracer
-  if (segment.getDurationInMillis() < ttConfig.explain_threshold) {
-    return
-  }
-  const slowQuery = new SlowQuery(segment, type, query, trace)
 
+  // If DT is enabled and the segment is part of a sampled transaction
+  // (i.e. we are creating a span event for this segment), then we need
+  // to collect the sql trace.
+  var slowQuery
   switch (ttConfig.record_sql) {
     case 'raw':
+      slowQuery = new SlowQuery(segment, type, query, trace)
       logger.trace('recording raw sql')
       segment.parameters.sql = slowQuery.query
       break
     case 'obfuscated':
+      slowQuery = new SlowQuery(segment, type, query, trace)
       logger.trace('recording obfuscated sql')
       segment.parameters.sql_obfuscated = slowQuery.obfuscated
       break
     default:
       logger.trace(
-        'not collecting slow-query because transaction_tracer.record_sql was set to %s',
+        'not recording sql statement, transaction_tracer.record_sql was set to %s',
         ttConfig.record_sql
       )
       return
   }
+
+  if (segment.getDurationInMillis() < ttConfig.explain_threshold) {
+    return
+  }
+
+  slowQuery = slowQuery || new SlowQuery(segment, type, query, trace)
+
   segment.parameters.backtrace = slowQuery.trace
 
   if (!this.config.slow_sql.enabled) {
@@ -158,7 +167,7 @@ QuerySample.prototype.getParams = function getParams() {
     params.database_name = segmentParams.database_name
   }
 
-  if (this.tracer.config.feature_flag.distributed_tracing) {
+  if (this.tracer.config.distributed_tracing.enabled) {
     this.trace.segment.transaction.addDistributedTraceIntrinsics(params)
   }
 

package/lib/environment.js

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

package/lib/errors/index.js

@@ -170,7 +170,7 @@ function _getErrorEventIntrinsicAttrs(transaction, errorClass, message, timestam
       attributes["nr.syntheticsMonitorId"] = transaction.syntheticsData.monitorId
     }
 
-    if (transaction.agent.config.feature_flag.distributed_tracing) {
+    if (transaction.agent.config.distributed_tracing.enabled) {
       transaction.addDistributedTraceIntrinsics(attributes)
     } else {
       attributes['nr.referringTransactionGuid'] = transaction.referringTransactionGuid

package/lib/feature_flags.js

@@ -5,7 +5,6 @@ exports.prerelease = {
   custom_instrumentation: true,
   custom_metrics: true,
   express5: false,
-  distributed_tracing: false,
   await_support: true,
   synthetics: true,
   native_metrics: true,

package/lib/harvest.js

@@ -76,7 +76,9 @@ class Harvest {
     if (this._events) {
       for (let i = 0; i < this._events.length; ++i) {
         if (this._events[i]) {
-          this.agent.events.merge(this._events[i][2])
+          this.agent.events.merge(
+            this._events[i].toMerge
+          )
         }
       }
     }
@@ -359,7 +361,8 @@ class Harvest {
 
     const self = this
     const agent = this.agent
-    a.eachOfSeries(this._events, function sendEachPayload(payload, i, cb) {
+    a.eachOfSeries(this._events, function sendEachPayload(obj, i, cb) {
+      const payload = obj.payload
       agent.collector.analyticsEvents(payload, function onAnalyticsEvents(err) {
         if (self._shouldClearData(err, 'events')) {
           self._events[i] = null
@@ -469,7 +472,7 @@ class Harvest {
 
   _sendSpanEvents(callback) {
     const config = this.agent.config
-    if (!config.span_events.enabled || !config.feature_flag.distributed_tracing) {
+    if (!config.span_events.enabled || !config.distributed_tracing.enabled) {
       logger.debug('Span events collection disabled.')
       this._spanEventsQueues = null
       return setImmediate(callback)
@@ -519,28 +522,43 @@ class Harvest {
       return []
     }
     if (queue.length < queue.limit / 3) {
-      return [[
-        this.agent.config.run_id,
-        {reservoir_size: queue.limit, events_seen: queue.seen},
-        queue.toArray()
-      ]]
+      return [{
+        toMerge: queue,
+        payload: [
+          this.agent.config.run_id,
+          {reservoir_size: queue.limit, events_seen: queue.seen},
+          queue.toArray()
+        ]
+      }]
     }
 
     // Our payload is large, so split it in half.
-    const events = queue.toArray()
+    // TODO: update this to pull the priority off the event when DT is released
+    const events = queue.getRawEvents()
     const size = Math.floor(queue.length / 2)
     const limit = Math.floor(queue.limit / 2)
     const seen = Math.floor(queue.seen / 2)
+    const firstHalf = events.splice(0, size)
 
-    return [[
-      this.agent.config.run_id,
-      {reservoir_size: limit, events_seen: seen},
-      events.splice(0, size)
-    ], [
-      this.agent.config.run_id,
-      {reservoir_size: queue.limit - limit, events_seen: queue.seen - seen},
-      events
-    ]]
+    return [{
+      toMerge: firstHalf,
+      payload: [
+        this.agent.config.run_id,
+        {reservoir_size: limit, events_seen: seen},
+        firstHalf.map(rawEventsToValues)
+      ]
+    }, {
+      toMerge: events,
+      payload: [
+        this.agent.config.run_id,
+        {reservoir_size: queue.limit - limit, events_seen: queue.seen - seen},
+        events.map(rawEventsToValues)
+      ]
+    }]
+
+    function rawEventsToValues(ev) {
+      return ev.value
+    }
   }
 }
 

package/lib/instrumentation/core/crypto.js

@@ -12,7 +12,8 @@ function initialize(agent, crypto) {
       'pbkdf2',
       'randomBytes',
       'pseudoRandomBytes',
-      'randomFill'
+      'randomFill',
+      'scrypt'
     ],
     wrapCryptoMethod
   )

package/lib/instrumentation/core/fs.js

@@ -1,7 +1,7 @@
 'use strict'
 
-var record = require('../../metrics/recorders/generic.js')
-var NAMES = require('../../metrics/names.js')
+var record = require('../../metrics/recorders/generic')
+var NAMES = require('../../metrics/names')
 var wrap = require('../../shimmer').wrapMethod
 
 module.exports = initialize
@@ -46,6 +46,7 @@ function initialize(agent, fs) {
   ]
 
   wrap(fs, 'fs', methods, segment)
+  wrap(fs.realpath, 'fs.realpath', 'native', wrapRealPathNative)
   wrap(fs, 'fs', uninstrumented, agent.tracer.wrapFunctionNoSegment.bind(agent.tracer))
   wrap(fs, 'fs', ['watch'], wrapWatch)
   wrap(fs, 'fs', ['watchFile'], wrapWatchFile)
@@ -54,6 +55,10 @@ function initialize(agent, fs) {
     return agent.tracer.wrapFunctionLast(NAMES.FS.PREFIX + method, record, fn)
   }
 
+  function wrapRealPathNative(fn) {
+    return segment(fn, 'realpath.native')
+  }
+
   function wrapWatch(fn) {
     return function wrappedWatch() {
       var args = agent.tracer.slice(arguments)

package/lib/instrumentation/core/globals.js

@@ -8,6 +8,8 @@ module.exports = initialize
 
 
 function initialize(agent) {
+  let exceptionCallbackRegistered = false
+
   // `_fatalException` is an undocumented feature of domains, introduced in
   // Node.js v0.8. We use `_fatalException` because wrapping it will not
   // potentially change the behavior of the server unlike listening for
@@ -16,7 +18,7 @@ function initialize(agent) {
     return function wrappedFatalException(error) {
       // Only record the error if we are not currently within an instrumented
       // domain.
-      if (!process.domain) {
+      if (!process.domain && !exceptionCallbackRegistered) {
         agent.errors.add(null, error)
         agent.tracer.segment = null
       }
@@ -45,6 +47,20 @@ function initialize(agent) {
     }
   }
 
+  shimmer.wrapMethod(
+    process,
+    'process',
+    'setUncaughtExceptionCaptureCallback',
+    wrapUncaughtExceptionCallback
+  )
+
+  function wrapUncaughtExceptionCallback(original) {
+    return function wrapped(fn) {
+      exceptionCallbackRegistered = fn !== null
+      return original.apply(this, arguments)
+    }
+  }
+
   // This will initialize the most optimal native-promise instrumentation that
   // we have available.
   asyncHooks(agent)

package/lib/instrumentation/core/http-outbound.js

@@ -6,11 +6,19 @@ var urltils = require('../../util/urltils')
 var hashes = require('../../util/hashes')
 var logger = require('../../logger').child({component: 'outbound'})
 var shimmer = require('../../shimmer')
+var util = require('util')
+var url = require('url')
+var copy = require('../../util/copy')
 
 const DEFAULT_HOST = 'localhost'
 const DEFAULT_PORT = 80
 const DEFAULT_SSL_PORT = 443
 
+const NEWRELIC_ID_HEADER = 'x-newrelic-id'
+const NEWRELIC_TRACE_HEADER = 'newrelic'
+const NEWRELIC_TRANSACTION_HEADER = 'x-newrelic-transaction'
+const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
+
 /**
  * Instruments an outbound HTTP request.
  *
@@ -21,6 +29,12 @@ const DEFAULT_SSL_PORT = 443
  * @return {http.ClientRequest} The instrumented outbound request.
  */
 module.exports = function instrumentOutbound(agent, opts, makeRequest) {
+  if (typeof opts === 'string') {
+    opts = url.parse(opts)
+  } else {
+    opts = copy.shallow(opts)
+  }
+
   let hostname = opts.hostname || opts.host || DEFAULT_HOST
   let port = opts.port || opts.defaultPort
   if (!port) {
@@ -32,7 +46,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
       'Invalid host name (%s) or port (%s) for outbound request.',
       hostname, port
     )
-    return makeRequest()
+    return makeRequest(opts)
   }
 
   // Technically we shouldn't append the port if this is an https request on 443
@@ -54,8 +68,48 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
   )
 
   function instrumentRequest(segment) {
+    const transaction = segment.transaction
+    const outboundHeaders = Object.create(null)
+
+    // FLAG: synthetics
+    if (
+      agent.config.feature_flag.synthetics &&
+      agent.config.encoding_key &&
+      transaction.syntheticsHeader
+    ) {
+      outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
+    }
+
+    // If CAT is enabled, inject the transaction header.
+    // TODO: abstract header logic shared with TransactionShim#insertCATRequestHeaders
+    if (agent.config.cross_application_tracer.enabled) {
+      if (agent.config.distributed_tracing.enabled) {
+        _addDistributedHeaders(transaction, outboundHeaders)
+      } else if (agent.config.encoding_key) {
+        _addCATHeaders(agent, transaction, outboundHeaders)
+      } else {
+        logger.trace('No encoding key found, not adding CAT headers')
+      }
+    }
+
+    if (util.isArray(opts.headers)) {
+      opts.headers = opts.headers.slice()
+      Array.prototype.push.apply(
+        opts.headers,
+        Object.keys(outboundHeaders).map(function getHeaderTuples(key) {
+          return [key, outboundHeaders[key]]
+        })
+      )
+    } else {
+      opts.headers = Object.assign(
+        Object.create(null),
+        opts.headers,
+        outboundHeaders
+      )
+    }
+
     segment.start()
-    const request = makeRequest()
+    const request = makeRequest(opts)
     const parsed = urltils.scrubAndParseParameters(request.path)
     const proto = parsed.protocol || opts.protocol || 'http:'
     segment.name += parsed.path
@@ -129,7 +183,7 @@ function handleResponse(segment, hostname, req, res) {
   const agent = segment.transaction.agent
   if (
     agent.config.cross_application_tracer.enabled &&
-    !agent.config.feature_flag.distributed_tracing
+    !agent.config.distributed_tracing.enabled
   ) {
     pullCatHeaders(agent.config, segment, hostname, res.headers['x-newrelic-app-data'])
   }
@@ -202,3 +256,48 @@ function _makeNonEnumerable(obj, prop) {
     logger.debug(e, 'Failed to make %s non enumerable.', prop)
   }
 }
+
+function _addDistributedHeaders(tx, outboundHeaders) {
+  try {
+    const txData = tx.createDistributedTracePayload().httpSafe()
+    outboundHeaders[NEWRELIC_TRACE_HEADER] = txData
+
+    logger.trace(
+      'Added outbound request distributed tracing headers in transaction %s',
+      tx.id
+    )
+  } catch (err) {
+    logger.trace(err, 'Failed to create distributed trace payload')
+  }
+}
+
+function _addCATHeaders(agent, tx, outboundHeaders) {
+  if (agent.config.obfuscatedId) {
+    outboundHeaders[NEWRELIC_ID_HEADER] = agent.config.obfuscatedId
+  }
+
+  var pathHash = hashes.calculatePathHash(
+    agent.config.applications()[0],
+    tx.getFullName() || '',
+    tx.referringPathHash
+  )
+  tx.pushPathHash(pathHash)
+
+  try {
+    let txData = JSON.stringify([
+      tx.id,
+      false,
+      tx.tripId || tx.id,
+      pathHash
+    ])
+    txData = hashes.obfuscateNameUsingKey(txData, agent.config.encoding_key)
+    outboundHeaders[NEWRELIC_TRANSACTION_HEADER] = txData
+
+    logger.trace(
+      'Added outbound request CAT headers in transaction %s',
+      tx.id
+    )
+  } catch (err) {
+    logger.trace(err, 'Failed to create CAT payload')
+  }
+}

package/lib/instrumentation/core/http.js

@@ -11,7 +11,6 @@ var url = require('url')
 var urltils = require('../../util/urltils')
 var properties = require('../../util/properties')
 var psemver = require('../../util/process-version')
-var copy = require('../../util/copy')
 
 const NAMES = require('../../metrics/names')
 const DESTS = require('../../config/attribute-filter').DESTINATIONS
@@ -206,7 +205,7 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
       }
     }
     if (agent.config.cross_application_tracer.enabled) {
-      if (agent.config.feature_flag.distributed_tracing) {
+      if (agent.config.distributed_tracing.enabled) {
         const payload = request.headers[NEWRELIC_TRACE_HEADER]
         if (payload) {
           logger.trace(
@@ -499,54 +498,10 @@ function wrapRequest(agent, request) {
 
     const args = agent.tracer.slice(arguments)
     const context = this
-    const outboundHeaders = Object.create(null)
-
-    // FLAG: synthetics
-    if (
-      agent.config.feature_flag.synthetics &&
-      agent.config.encoding_key &&
-      transaction.syntheticsHeader
-    ) {
-      outboundHeaders[NEWRELIC_SYNTHETICS_HEADER] = transaction.syntheticsHeader
-    }
-
-    // If CAT is enabled, inject the transaction header.
-    // TODO: abstract header logic shared with TransactionShim#insertCATRequestHeaders
-    if (agent.config.cross_application_tracer.enabled) {
-      if (agent.config.feature_flag.distributed_tracing) {
-        _addDistributedHeaders(transaction, outboundHeaders)
-      } else if (agent.config.encoding_key) {
-        _addCATHeaders(agent, transaction, outboundHeaders)
-      } else {
-        logger.trace('No encoding key found, not adding CAT headers')
-      }
-    }
-
-    if (typeof options === 'string') {
-      options = url.parse(options)
-    } else {
-      options = copy.shallow(options)
-    }
-
-    if (util.isArray(options.headers)) {
-      options.headers = options.headers.slice()
-      Array.prototype.push.apply(
-        options.headers,
-        Object.keys(outboundHeaders).map(function getHeaderTuples(key) {
-          return [key, outboundHeaders[key]]
-        })
-      )
-    } else {
-      options.headers = Object.assign(
-        Object.create(null),
-        options.headers,
-        outboundHeaders
-      )
-    }
-    args[0] = options
 
     // hostname & port logic pulled directly from node's 0.10 lib/http.js
-    return instrumentOutbound(agent, options, function makeRequest() {
+    return instrumentOutbound(agent, options, function makeRequest(opts) {
+      args[0] = opts
       return request.apply(context, args)
     })
   }
@@ -738,7 +693,7 @@ module.exports = function initialize(agent, http, moduleName) {
  *
  * @param {string} header - The raw X-NewRelic-Synthetics header
  * @param {string} encKey - Encoding key handed down from the server
- * @param {̄Array} trustedIds - Array of accounts to trust the header from.
+ * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
  * @param {Transaction} transaction - Where the synthetics data is attached to.
  */
 function handleSyntheticsHeader(header, encKey, trustedIds, transaction) {
@@ -756,8 +711,8 @@ function handleSyntheticsHeader(header, encKey, trustedIds, transaction) {
  *
  * @param {string} header - The raw X-NewRelic-Synthetics header
  * @param {string} encKey - Encoding key handed down from the server
- * @param {̄Array} trustedIds - Array of accounts to trust the header from.
- * @return {Object or null} - On successful parse and verification an object of
+ * @param {Array.<number>} trustedIds - Array of accounts to trust the header from.
+ * @return {Object|null} - On successful parse and verification an object of
  *                            synthetics data is returned, otherwise null is
  *                            returned.
  */
@@ -877,48 +832,3 @@ function _collectHeaders(headers, nameMap, prefix, tx) {
     }
   }
 }
-
-function _addDistributedHeaders(tx, outboundHeaders) {
-  try {
-    const txData = tx.createDistributedTracePayload().httpSafe()
-    outboundHeaders[NEWRELIC_TRACE_HEADER] = txData
-
-    logger.trace(
-      'Added outbound request distributed tracing headers in transaction %s',
-      tx.id
-    )
-  } catch (err) {
-    logger.trace(err, 'Failed to create distributed trace payload')
-  }
-}
-
-function _addCATHeaders(agent, tx, outboundHeaders) {
-  if (agent.config.obfuscatedId) {
-    outboundHeaders[NEWRELIC_ID_HEADER] = agent.config.obfuscatedId
-  }
-
-  var pathHash = hashes.calculatePathHash(
-    agent.config.applications()[0],
-    tx.getFullName() || '',
-    tx.referringPathHash
-  )
-  tx.pushPathHash(pathHash)
-
-  try {
-    let txData = JSON.stringify([
-      tx.id,
-      false,
-      tx.tripId || tx.id,
-      pathHash
-    ])
-    txData = hashes.obfuscateNameUsingKey(txData, agent.config.encoding_key)
-    outboundHeaders[NEWRELIC_TRANSACTION_HEADER] = txData
-
-    logger.trace(
-      'Added outbound request CAT headers in transaction %s',
-      tx.id
-    )
-  } catch (err) {
-    logger.trace(err, 'Failed to create CAT payload')
-  }
-}