newrelic 5.3.0 → 5.6.2

package/lib/transaction/index.js

@@ -43,7 +43,6 @@ const TRANSPORT_TYPES = {
 }
 const TRANSPORT_TYPES_SET = _makeValueSet(TRANSPORT_TYPES)
 const REQUIRED_DT_KEYS = ['ty', 'ac', 'ap', 'tr', 'ti']
-const TRANSACTION_SCOPE = 'transaction'
 const DTPayload = require('./dt-payload')
 const DTPayloadStub = DTPayload.Stub
 
@@ -380,7 +379,6 @@ function finalizeNameFromUri(requestURL, statusCode) {
       for (var key in params) {
         if (props.hasOwn(params, key)) {
           this.trace.attributes.addAttribute(
-            TRANSACTION_SCOPE,
             DESTS.NONE,
             'request.parameters.' + key,
             params[key]
@@ -426,7 +424,6 @@ Transaction.prototype._markAsWeb = function _markAsWeb(rawURL) {
   for (var key in params) {
     if (props.hasOwn(params, key)) {
       this.trace.attributes.addAttribute(
-        TRANSACTION_SCOPE,
         DESTS.NONE,
         'request.parameters.' + key,
         params[key]
@@ -990,7 +987,9 @@ function addDistributedTraceIntrinsics(attrs) {
 Transaction.prototype._calculatePriority = function _calculatePriority() {
   if (this.priority === null) {
     this.priority = Math.random()
-    this.sampled = this.agent.transactionSampler.shouldSample(this)
+    // We want to separate the priority roll from the decision roll to
+    // avoid biasing the priority range
+    this.sampled = this.agent.transactionSampler.shouldSample(Math.random())
     if (this.sampled) {
       this.priority += 1
     }
@@ -1020,7 +1019,6 @@ function addRequestParameters(requestParameters) {
   for (var key in requestParameters) {
     if (props.hasOwn(requestParameters, key)) {
       this.trace.attributes.addAttribute(
-        TRANSACTION_SCOPE,
         DESTS.NONE,
         'request.parameters.' + key,
         requestParameters[key]

package/lib/transaction/trace/exclusive-time-calculator.js

@@ -0,0 +1,145 @@
+'use strict'
+
+class ExclusiveCalculator {
+  constructor(root) {
+    this.toProcess = [root]
+    // use a second stack to do a post-order traversal
+    this.parentStack = []
+  }
+
+  /**
+   * Kicks off the exclusive duration calculation.  This is performed
+   * using a depth first, postorder traversal over the tree.
+   */
+  process() {
+    while (this.toProcess.length) {
+      const segment = this.toProcess.pop()
+      const children = segment.getChildren()
+      // when we hit a leaf, calc the exclusive time and report the time
+      // range to the parent
+      if (children.length === 0) {
+        segment._exclusiveDuration = segment.getDurationInMillis()
+        if (this.parentStack.length) {
+          this.finishLeaf(segment.timer.toRange())
+        }
+      } else {
+        // in the case we are processing an internal node, we just push it on the stack
+        // and push its children to be processed. all processing will be done after its
+        // children are all done (i.e. postorder)
+        this.parentStack.push({
+          childrenLeft: children.length,
+          segment: segment,
+          childPairs: []
+        })
+        for (var i = children.length - 1; i >= 0; --i) {
+          this.toProcess.push(children[i])
+        }
+      }
+    }
+  }
+
+  /**
+   * Updates the immediate parent in the parent stack that a leaf node has
+   * been processed.  If the parent isn't expecting any more children to
+   * be processed, it pops the stack and propagates the processing to
+   * more distant predecessors.
+   *
+   * @param {Array} childRange An array of start and end time for the finished leaf node
+   */
+  finishLeaf(childRange) {
+    let parent = this.parentStack[this.parentStack.length - 1]
+    // push the current segment's range pair up to the parent's child pairs
+    parent.childPairs = merge(parent.childPairs, [childRange])
+    // decrement the number of children expected for the current parent; process the
+    // parent if it is not expecting any further children to finish (i.e. the number
+    // of children left to process is 0).
+    while (--parent.childrenLeft === 0) {
+      // pull off the finished parent and assign the exclusive duration
+      const {segment: finishedParent, childPairs} = this.parentStack.pop()
+      const timer = finishedParent.timer
+      const finishedEnd = timer.getDurationInMillis() + timer.start
+      let duration = finishedParent.getDurationInMillis()
+      for (let i = 0; i < childPairs.length; ++i) {
+        const pair = childPairs[i]
+        // since these are non-overlapping and ordered by start time, the first one
+        // to start after the parent's end marks the end of the segments we care
+        // about.
+        if (pair[0] >= finishedEnd) {
+          break
+        }
+        duration -= Math.min(pair[1], finishedEnd) - pair[0]
+      }
+
+      finishedParent._exclusiveDuration = duration
+      parent = this.parentStack[this.parentStack.length - 1]
+      // since the parent was potentially a child of another segment, we need to
+      // rerun this for the parent's parent till we hit a parent with children yet
+      // to be processed.
+      if (parent) {
+        // merge the current child segments in with the finished parent's range
+        const inserted = merge(childPairs, [finishedParent.timer.toRange()])
+        // merge the finished parent's merged range into its parent's range
+        parent.childPairs = merge(parent.childPairs, inserted)
+      } else {
+        // in the case where the parent doesn't exist, we are done and can break out.
+        break
+      }
+    }
+  }
+}
+
+function merge(first, second) {
+  if (!first.length) {
+    return second
+  }
+
+  if (!second.length) {
+    return first
+  }
+
+  const res = []
+  var resIdx = 0
+  var firstIdx = 0
+  var secondIdx = 0
+  // N.B. this is destructive, it will be updating the end times for range arrays in
+  // the input arrays.  If we need to reuse these arrays for anything, this behavior
+  // must be changed.
+  var currInterval = first[firstIdx][0] < second[secondIdx][0]
+    ? first[firstIdx++]
+    : second[secondIdx++]
+
+  while (firstIdx < first.length && secondIdx < second.length) {
+    var next = first[firstIdx][0] < second[secondIdx][0]
+      ? first[firstIdx++]
+      : second[secondIdx++]
+    if (next[0] <= currInterval[1]) {
+      // if the segment overlaps, update the end of the current merged segment
+      currInterval[1] = Math.max(next[1], currInterval[1])
+    } else {
+      // if there is no overlap, start a new merging segment and push the old one
+      res[resIdx++] = currInterval
+      currInterval = next
+    }
+  }
+
+
+  const firstIsRemainder = firstIdx !== first.length
+  const remainder = firstIsRemainder ? first : second
+  let remainderIdx = firstIsRemainder ? firstIdx : secondIdx
+
+  // merge the segments overlapping with the current interval
+  while (remainder[remainderIdx] && remainder[remainderIdx][0] <= currInterval[1]) {
+    currInterval[1] = Math.max(remainder[remainderIdx++][1], currInterval[1])
+  }
+
+  res[resIdx++] = currInterval
+
+  // append the remaining non-overlapping ranges
+  for (;remainderIdx < remainder.length; ++remainderIdx) {
+    res[resIdx++] = remainder[remainderIdx]
+  }
+
+  return res
+}
+
+module.exports = ExclusiveCalculator

package/lib/transaction/trace/index.js

@@ -7,9 +7,9 @@ var logger = require('../../logger').child({component: 'trace'})
 
 
 var {DESTINATIONS} = require('../../config/attribute-filter')
-var NAMES = require('../../metrics/names')
 var FROM_MILLIS = 1e-3
-const TRANSACTION_SCOPE = 'transaction'
+const ATTRIBUTE_SCOPE = 'transaction'
+
 
 /**
  * A Trace holds the root of the Segment graph and produces the final
@@ -21,7 +21,6 @@ function Trace(transaction) {
   if (!transaction) throw new Error('All traces must be associated with a transaction.')
 
   this.transaction = transaction
-  const filter = transaction.agent.config.attributeFilter
 
   this.root = new Segment(transaction, 'ROOT')
   this.root.start()
@@ -30,15 +29,14 @@ function Trace(transaction) {
   this.segmentsSeen = 0
   this.totalTimeCache = null
 
-  this.custom = new Attributes({limit: 64, filter})
-  this.attributes = new Attributes({filter})
+  this.custom = new Attributes(ATTRIBUTE_SCOPE, 64)
+  this.attributes = new Attributes(ATTRIBUTE_SCOPE)
 
   // sending displayName if set by user
   var displayName = transaction.agent.config.getDisplayHost()
   var hostName = transaction.agent.config.getHostnameSafe()
   if (displayName !== hostName) {
     this.attributes.addAttribute(
-      TRANSACTION_SCOPE,
       DESTINATIONS.TRANS_COMMON,
       'host.displayName',
       displayName
@@ -52,12 +50,16 @@ function Trace(transaction) {
  * segments that support recording.
  */
 Trace.prototype.end = function end() {
-  var segments = [this.root]
+  const segments = [this.root]
 
   while (segments.length) {
-    var segment = segments.pop()
-    _softEndSegment(segment)
-    Array.prototype.push.apply(segments, segment.getChildren())
+    const segment = segments.pop()
+    segment.finalize()
+
+    const children = segment.getChildren()
+    for (let i = 0; i < children.length; ++i) {
+      segments.push(children[i])
+    }
   }
 }
 
@@ -89,10 +91,11 @@ Trace.prototype.generateSpanEvents = function generateSpanEvents() {
       // the spans as seen.
       spanAggregator.addSegment(segment, segmentInfo.parentId)
 
-      Array.prototype.push.apply(
-        toProcess,
-        segment.getChildren().map(child => new DTTraceNode(child, segment.id))
-      )
+      const nodes = segment.getChildren()
+      for (let i = 0; i < nodes.length; ++i) {
+        const node = new DTTraceNode(nodes[i], segment.id)
+        toProcess.push(node)
+      }
     }
   }
 }
@@ -102,15 +105,6 @@ function DTTraceNode(segment, parentId) {
   this.parentId = parentId
 }
 
-function _softEndSegment(segment) {
-  if (segment.timer.softEnd()) {
-    segment._updateRootTimer()
-    // timer.softEnd() returns true if the timer was ended prematurely, so
-    // in that case we can name the segment as truncated
-    segment.name = NAMES.TRUNCATED.PREFIX + segment.name
-  }
-}
-
 /**
  * Add a child to the list of segments.
  *
@@ -157,12 +151,7 @@ Trace.prototype.addCustomAttribute = function addCustomAttribute(key, value) {
     )
   }
 
-  this.custom.addAttribute(
-    TRANSACTION_SCOPE,
-    DESTINATIONS.TRANS_SCOPE,
-    key,
-    value
-  )
+  this.custom.addAttribute(DESTINATIONS.TRANS_SCOPE, key, value)
 }
 
 /**

package/lib/transaction/trace/segment.js

@@ -1,20 +1,22 @@
 'use strict'
 
-var {DESTINATIONS} = require('../../config/attribute-filter')
-var logger = require('../../logger').child({component: 'segment'})
-var sumChildren = require('../../util/sum-children')
-var Timer = require('../../timer')
-var urltils = require('../../util/urltils')
-var hashes = require('../../util/hashes')
-const Attributes = require('../../attributes')
+const {DESTINATIONS} = require('../../config/attribute-filter')
+const logger = require('../../logger').child({component: 'segment'})
+const Timer = require('../../timer')
+const urltils = require('../../util/urltils')
+const hashes = require('../../util/hashes')
 
+const Attributes = require('../../attributes')
+const ExclusiveCalculator = require('./exclusive-time-calculator')
 
+const NAMES = require('../../metrics/names')
 const INSTANCE_UNKNOWN = 'unknown'
 const STATE = {
   EXTERNAL: 'EXTERNAL',
   CALLBACK: 'CALLBACK'
 }
-const SEGMENT_SCOPE = 'segment'
+const ATTRIBUTE_SCOPE = 'segment'
+
 
 /**
  * Initializes the segment and binds the recorder to itself, if provided.
@@ -49,8 +51,7 @@ function TraceSegment(transaction, name, recorder) {
     transaction.addRecorder(recorder.bind(null, this))
   }
 
-  const filter = transaction.agent.config.attributeFilter
-  this.attributes = new Attributes({filter})
+  this.attributes = new Attributes(ATTRIBUTE_SCOPE)
 
   this.children = []
 
@@ -78,8 +79,7 @@ function TraceSegment(transaction, name, recorder) {
 TraceSegment.prototype.addAttribute =
 function addAttribute(key, value, truncateExempt = false) {
   this.attributes.addAttribute(
-    SEGMENT_SCOPE,
-    DESTINATIONS.TRANS_SEGMENT,
+    DESTINATIONS.SEGMENT_SCOPE,
     key,
     value,
     truncateExempt
@@ -126,14 +126,9 @@ function captureDBInstanceAttributes(host, port, database) {
     if (!host || host === 'UNKNOWN_BOX') { // Config's default name of a host.
       host = INSTANCE_UNKNOWN
     }
-    this.attributes.addAttributes(
-      SEGMENT_SCOPE,
-      DESTINATIONS.TRANS_SEGMENT,
-      {
-        host,
-        port_path_or_id: String(port)
-      }
-    )
+
+    this.addAttribute('host', host)
+    this.addAttribute('port_path_or_id', String(port))
   }
 }
 
@@ -182,10 +177,7 @@ TraceSegment.prototype.markAsWeb = function markAsWeb() {
   var traceAttrs = transaction.trace.attributes.get(DESTINATIONS.TRANS_TRACE)
   Object.keys(traceAttrs).forEach((key) => {
     if (!this.attributes.has(key)) {
-      this.addAttribute(
-        key,
-        traceAttrs[key]
-      )
+      this.addAttribute(key, traceAttrs[key])
     }
   })
 }
@@ -221,6 +213,20 @@ TraceSegment.prototype.end = function end() {
   this._updateRootTimer()
 }
 
+TraceSegment.prototype.finalize = function finalize() {
+  if (this.timer.softEnd()) {
+    this._updateRootTimer()
+    // timer.softEnd() returns true if the timer was ended prematurely, so
+    // in that case we can name the segment as truncated
+    this.name = NAMES.TRUNCATED.PREFIX + this.name
+  }
+
+  this.addAttribute(
+    'nr_exclusive_duration_millis',
+    this.getExclusiveDurationInMillis()
+  )
+}
+
 /**
  * Helper to set the end of the root timer to this segment's root if it is later
  * in time.
@@ -309,17 +315,12 @@ function _setExclusiveDurationInMillis(duration) {
 TraceSegment.prototype.getExclusiveDurationInMillis = getExclusiveDurationInMillis
 
 function getExclusiveDurationInMillis() {
-  if (this._exclusiveDuration) return this._exclusiveDuration
-
-  var total = this.getDurationInMillis()
-  var end = this.timer.toRange()[1]
-
-  if (this.children.length > 0) {
-    // convert the list of start, duration pairs to start, end pairs
-    total -= sumChildren(this._getChildPairs(end), end)
+  if (this._exclusiveDuration == null) {
+    // Calculate the exclusive time for the subtree rooted at `this`
+    const calculator = new ExclusiveCalculator(this)
+    calculator.process()
   }
-
-  return total
+  return this._exclusiveDuration
 }
 
 TraceSegment.prototype.getChildren = function getChildren() {
@@ -401,59 +402,47 @@ TraceSegment.prototype._getChildPairs = function _getChildPairs(end) {
  */
 TraceSegment.prototype.toJSON = function toJSON() {
   // use depth-first search on the segment tree using stack
-  var segmentsToProcess = [this]
-  // used to keep track of the last parent to add child JSONs to, it will hold
-  // pairs of the parent serialized segment and number of children it is expecting
-  // to have added
-  var parentStack = []
-  var resultTreeJson = null
+  const resultDest = []
+  // array of objects relating a segment and the destination for its
+  // serialized data.
+  const segmentsToProcess = [{
+    segment: this,
+    destination: resultDest
+  }]
 
   while (segmentsToProcess.length !== 0) {
-    const segment = segmentsToProcess.pop()
-
-    segment.addAttribute(
-      'nr_exclusive_duration_millis',
-      segment.getExclusiveDurationInMillis()
-    )
+    const {segment, destination} = segmentsToProcess.pop()
 
-    var start = segment.timer.startedRelativeTo(segment.transaction.trace.root.timer)
-    var duration = segment.getDurationInMillis()
+    const start = segment.timer.startedRelativeTo(segment.transaction.trace.root.timer)
+    const duration = segment.getDurationInMillis()
 
-    var segmentChildren = segment.getCollectedChildren()
+    const segmentChildren = segment.getCollectedChildren()
+    const childArray = []
 
-    var serializedSegment = [
+    // push serialized data into the specified destination
+    destination.push([
       start,
       start + duration,
       segment.name,
       segment.getAttributes(),
-      new Array(segmentChildren.length)
-    ]
-
-    if (resultTreeJson === null) {
-      resultTreeJson = serializedSegment
-    }
-
-    if (parentStack.length !== 0) {
-      // get last visited parent
-      var parent = parentStack[parentStack.length - 1]
-
-      var parentChildren = parent[0][4]
-      var childIndex = --parent[1]
-
-      parentChildren[childIndex] = serializedSegment
-
-      // if the parent received all its children data, remove the parent from the stack
-      if (childIndex === 0) {
-        parentStack.pop()
-      }
-    }
+      childArray
+    ])
 
     if (segmentChildren.length) {
-      parentStack.push([serializedSegment, segmentChildren.length])
-      segmentsToProcess = segmentsToProcess.concat(segmentChildren)
+      // push the children and the parent's children array into the stack.
+      // to preserve the chronological order of the children, push them
+      // onto the stack backwards (so the first one created is on top).
+      for (var i = segmentChildren.length - 1; i >= 0; --i) {
+        segmentsToProcess.push({
+          segment: segmentChildren[i],
+          destination: childArray
+        })
+      }
     }
   }
-  return resultTreeJson
+
+  // pull the result out of the array we serialized it into
+  return resultDest[0]
 }
 
 module.exports = TraceSegment

package/lib/util/attribute-types.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const VALID_ATTR_TYPES = new Set([
+  'string',
+  'number',
+  'boolean'
+])
+
+/**
+ * Checks incoming attribute value against valid types:
+ * string, number, & boolean.
+ *
+ * @param {*} val
+ *
+ * @return {boolean}
+ */
+function isValidType(val) {
+  return VALID_ATTR_TYPES.has(typeof val)
+}
+
+module.exports = isValidType

package/lib/util/byte-limit.js

@@ -7,7 +7,20 @@
  * @param {number} limit - String byte limit
  */
 function isValidLength(str, limit) {
-  return Buffer.byteLength(str, 'utf8') < limit
+  return Buffer.byteLength(str, 'utf8') <= limit
+}
+
+/**
+ * Returns the relative position of the end of the string (in bytes) and the limit.
+ * >1 if the string is longer than the limit
+ * 0 if the string is at the limit
+ * <1 if the string is shorter than the limit
+ *
+ * @param {string} str
+ * @param {number} limit - String byte limit
+ */
+function compareLength(str, limit) {
+  return Buffer.byteLength(str) - limit
 }
 
 /**
@@ -22,19 +35,35 @@ function isValidLength(str, limit) {
  */
 function truncate(val, limit) {
   // First truncation handles the simple case of only one-byte characters.
-  if (!isValidLength(val + 1)) {
-    val = val.substring(0, limit)
+  val = val.substring(0, limit)
+  if (isValidLength(val, limit)) {
+    return val
   }
 
+
   // Our limitation is on byte length, and the string could contain multi-byte
-  // characters. Doing a byte-substring could chop a character in half. We need
-  // to pop the remaining characters off one by one until we have a good length.
-  var l = val.length
-  while (!isValidLength(val, limit + 1)) {
-    val = val.substring(0, --l)
+  // characters. Doing a byte-substring could chop a character in half. Instead
+  // we do a binary search over the byte length of the substrings.
+  var substrLen = val.length
+  var delta = Math.ceil(substrLen / 2)
+  var cmpVal = compareLength(val.substring(0, substrLen), limit)
+
+  // Continue the binary search till:
+  // 1) The string is the desired length (i.e. cmpVal = 0) OR
+  // 2) The desired string must split a character to acheive the desired byte length
+  //    In this case, we should cut the character that would be split.
+  //    (i.e. delta > 1 character OR the string is larger than the limit)
+  var substr
+  while (cmpVal && (cmpVal > 0 || delta > 1)) {
+    substrLen = cmpVal < 0 ? substrLen + delta : substrLen - delta
+    substr = val.substring(0, substrLen)
+    cmpVal = compareLength(substr, limit)
+    delta = Math.ceil(delta / 2)
   }
-  return val
+
+  return substr
 }
 
 module.exports.isValidLength = isValidLength
+module.exports.compareLength = compareLength
 module.exports.truncate = truncate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "5.3.0",
+  "version": "5.6.2",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "licenses": [
     {

package/lib/util/sum-children.js

@@ -1,52 +0,0 @@
-'use strict'
-
-/**
- * Given an ordered list of disjoint intervals and a new interval to fold into
- * it, determine if the new interval is a sub-interval (in which case it's
- * redundant), an overlapping interval (in which case, replace the most recent
- * interval on the list with an interval representing the union of the new and
- * last intervals), or otherwise (it's disjoint to what we already
- * have, in which case add it to the list). Meant to be used with
- * Array.reduce().
- *
- * Assumes the list being reduced is sorted by interval start time.
- *
- * @param {Array} accum  The accumulated list of reduced intervals.
- * @param {Array} newest A new pair of range start and end to compare to the
-*                        existing intervals.
- *
- * @return {Array} A list of intervals updated to include the new interval.
- */
-
-function sumChildren(pairs, parentEnd) {
-  if (!pairs.length) return 0
-
-  pairs.sort(function cb_sort(a, b) {
-    return a[0] - b[0]
-  })
-
-
-  var start = pairs[0][0]
-  var end = start
-  var diff = 0
-  var segmentEnd
-  var pair
-
-  for (var i = 0, l = pairs.length; i < l; ++i) {
-    pair = pairs[i]
-
-    if (pair[0] > parentEnd) break
-    segmentEnd = pair[1] > parentEnd ? parentEnd : pair[1]
-
-    if (pair[0] > end) {
-      diff += pair[0] - end
-      end = segmentEnd
-    } else if (segmentEnd > end) {
-      end = segmentEnd
-    }
-  }
-
-  return end - start - diff
-}
-
-module.exports = sumChildren