newrelic 6.7.0 → 6.10.0

package/lib/instrumentation/core/http.js

@@ -71,6 +71,13 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
     const segment = tracer.createSegment(request.url, recordWeb)
     segment.start()
 
+    if (request.method != null) {
+      segment.addSpanAttribute(
+        'request.method',
+        request.method
+      )
+    }
+
     if (txInfo) {
       // Seed segment stack to enable parenting logic leveraged by
       // web framework instrumentations.
@@ -98,6 +105,11 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
       transaction.url
     )
 
+    segment.addSpanAttribute(
+      'request.uri',
+      transaction.url
+    )
+
     // store the port on which this transaction runs
     if (this.address instanceof Function) {
       var address = this.address()
@@ -117,28 +129,30 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
       transaction.queueTime = Date.now() - queueTimeStamp
     }
 
+    const synthHeader = request.headers[NEWRELIC_SYNTHETICS_HEADER]
+
+    if (synthHeader && agent.config.trusted_account_ids && agent.config.encoding_key) {
+      handleSyntheticsHeader(
+        synthHeader,
+        agent.config.encoding_key,
+        agent.config.trusted_account_ids,
+        transaction
+      )
+    }
+
     if (agent.config.distributed_tracing.enabled) {
       // Node http headers are automatically lowercase
       transaction.acceptDistributedTraceHeaders(transport, request.headers)
     } else if (agent.config.cross_application_tracer.enabled) {
-      var encKey = agent.config.encoding_key
-      var incomingCatId = request.headers[NEWRELIC_ID_HEADER]
-      var obfTransaction = request.headers[NEWRELIC_TRANSACTION_HEADER]
-      var synthHeader = request.headers[NEWRELIC_SYNTHETICS_HEADER]
-      if (encKey) {
-        cat.handleCatHeaders(incomingCatId, obfTransaction, encKey, transaction)
+      const incomingCatId = request.headers[NEWRELIC_ID_HEADER]
+      const obfTransaction = request.headers[NEWRELIC_TRANSACTION_HEADER]
+
+      if (agent.config.encoding_key) {
+        cat.handleCatHeaders(incomingCatId, obfTransaction, agent.config.encoding_key, transaction)
         if (transaction.incomingCatId) {
           logger.trace('Got inbound request CAT headers in transaction %s',
             transaction.id)
         }
-        if (synthHeader && agent.config.trusted_account_ids) {
-          handleSyntheticsHeader(
-            synthHeader,
-            encKey,
-            agent.config.trusted_account_ids,
-            transaction
-          )
-        }
       }
     }
 
@@ -170,6 +184,8 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
               'http.statusCode',
               responseCode
             )
+              
+            segment.addSpanAttribute('http.statusCode', responseCode)
 
             /*
             TODO: remove with next major release
@@ -190,6 +206,8 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
             response.statusMessage
           )
 
+          segment.addSpanAttribute('http.statusText', response.statusMessage)
+
           /*
             TODO: remove with next major release
             httpResponseMessage attribute is deprecated

package/lib/metrics/normalizer.js

@@ -4,7 +4,7 @@ var EventEmitter = require('events').EventEmitter
 var util = require('util')
 var logger = require('../logger').child({component: 'metric_normalizer'})
 var deepEqual = require('../util/deep-equal')
-var Rule = require('./normalizer/rule')
+var NormalizerRule = require('./normalizer/rule')
 var NAMES = require('../metrics/names.js')
 
 
@@ -82,7 +82,7 @@ MetricNormalizer.prototype.load = function load(json) {
 
     json.forEach(function cb_forEach(ruleJSON) {
       // no need to add the same rule twice
-      var rule = new Rule(ruleJSON)
+      var rule = new NormalizerRule(ruleJSON)
       if (!this.rules.find(deepEqual.bind(null, rule))) {
         this.rules.push(rule)
         logger.trace("Loaded %s normalization rule: %s", this.type, rule)
@@ -142,9 +142,9 @@ MetricNormalizer.prototype.loadFromConfig = function loadFromConfig() {
           : r.precedence > json.eval_order
       })
       if (insert === -1) {
-        this.rules.push(new Rule(json))
+        this.rules.push(new NormalizerRule(json))
       } else {
-        this.rules.splice(insert, 0, new Rule(json))
+        this.rules.splice(insert, 0, new NormalizerRule(json))
       }
     }, this)
   }
@@ -186,7 +186,7 @@ MetricNormalizer.prototype.addSimple = function addSimple(pattern, name) {
     json.ignore = true
   }
 
-  this.rules.unshift(new Rule(json))
+  this.rules.unshift(new NormalizerRule(json))
 }
 
 /**

package/lib/prioritized-attributes.js

@@ -0,0 +1,196 @@
+'use strict'
+
+const Config = require('./config')
+const logger = require('./logger').child({component: 'attributes'})
+const isValidType = require('./util/attribute-types')
+const byteUtils = require('./util/byte-limit')
+const properties = require('./util/properties')
+
+const ATTRIBUTE_PRIORITY = {
+  HIGH: Infinity,
+  LOW: -Infinity
+}
+
+class PrioritizedAttributes {
+  constructor(scope, limit = Infinity) {
+    this.filter = makeFilter(scope)
+    this.limit = limit
+
+    this.attributes = new Map()
+  }
+
+
+  isValidLength(str) {
+    return typeof str === 'number' || byteUtils.isValidLength(str, 255)
+  }
+
+  _set(destinations, key, value, truncateExempt, priority) {
+    this.attributes.set(key, {value, destinations, truncateExempt, priority})
+  }
+
+  get(dest) {
+    const attrs = Object.create(null)
+
+    for (let [key, attr] of this.attributes) {
+      if (!(attr.destinations & dest)) {
+        continue
+      }
+
+      attrs[key] = typeof attr.value === 'string' && !attr.truncateExempt
+        ? byteUtils.truncate(attr.value, 255)
+        : attr.value
+    }
+
+    return attrs
+  }
+
+  has(key) {
+    this.attributes.has(key)
+  }
+
+  reset() {
+    this.attributes = new Map()
+  }
+
+  addAttribute(
+    destinations,
+    key,
+    value,
+    truncateExempt = false,
+    priority = ATTRIBUTE_PRIORITY.HIGH
+  ) {
+    const existingAttribute = this.attributes.get(key)
+
+    let droppableAttributeKey = null
+    if (!existingAttribute && this.attributes.size === this.limit) {
+      droppableAttributeKey = this._getDroppableAttributeKey(priority)
+
+      if (!droppableAttributeKey) {
+        logger.debug(
+          `Maximum number of custom attributes have been added.
+          Dropping attribute ${key} with ${value} type.`
+        )
+
+        return
+      }
+    }
+
+    if (existingAttribute && priority < existingAttribute.priority) {
+      logger.debug('incoming priority for \'%s\' is lower than existing, not updating.', key)
+      logger.trace(
+        '%s attribute retained value: %s, ignored value: %s',
+        key,
+        existingAttribute.value,
+        value
+      )
+      return
+    }
+
+    if (!isValidType(value)) {
+      logger.debug(
+        'Not adding attribute %s with %s value type. This is expected for undefined' +
+        'attributes and only an issue if an attribute is not expected to be undefined' +
+        'or not of the type expected.',
+        key,
+        typeof value
+      )
+      return
+    }
+
+    if (!this.isValidLength(key)) {
+      logger.warn(
+        'Length limit exceeded for attribute name, not adding: %s',
+        key
+      )
+      return
+    }
+
+
+    // Only set the attribute if at least one destination passed
+    const validDestinations = this.filter(destinations, key)
+    if (!validDestinations) {
+      return
+    }
+
+    if (droppableAttributeKey) {
+      logger.trace(
+        'dropping existing lower priority attribute %s ' +
+        'to add higher priority attribute %s',
+        droppableAttributeKey,
+        key
+      )
+
+      this.attributes.delete(droppableAttributeKey)
+    }
+
+    this._set(validDestinations, key, value, truncateExempt, priority)
+  }
+
+  addAttributes(destinations, attrs) {
+    for (let key in attrs) {
+      if (properties.hasOwn(attrs, key)) {
+        this.addAttribute(destinations, key, attrs[key])
+      }
+    }
+  }
+
+  _getDroppableAttributeKey(incomingPriority) {
+    // There will never be anything lower priority to drop
+    if (incomingPriority === ATTRIBUTE_PRIORITY.LOW) {
+      return null
+    }
+
+    this.lastFoundIndexCache = this.lastFoundIndexCache || Object.create(null)
+    const lastFoundIndex = this.lastFoundIndexCache[incomingPriority]
+
+    // We've already dropped all items lower than incomingPriority.
+    // We can honor the cache because at the point by which we've dropped
+    // all lower priority items, due to being at max capacity, there will never be another
+    // lower-priority item added. Lower priority items are unable to drop higher priority items.
+    if (lastFoundIndex === -1) {
+      return null
+    }
+
+    // We can't reverse iterate w/o creating an array that will iterate,
+    // so we just iterate forward stopping once we've checked the last cached index.
+    let lowerPriorityAttributeName = null
+    let foundIndex = -1
+
+    let index = 0
+    for (const [key, attribute] of this.attributes) {
+      // Don't search past last found lower priority item.
+      // At the point of dropping items for this priority,
+      // lower priority items will never be added.
+      if (lastFoundIndex && index > lastFoundIndex) {
+        break
+      }
+
+      if (attribute.priority < incomingPriority) {
+        lowerPriorityAttributeName = key
+        foundIndex = index
+      }
+
+      index++
+    }
+
+    // Item may not get dropped, so we simply store the index as
+    // an upper maximum and allow a future pass to clear out.
+    this.lastFoundIndexCache[incomingPriority] = foundIndex
+
+    return lowerPriorityAttributeName
+  }
+}
+
+function makeFilter(scope) {
+  const {attributeFilter} = Config.getInstance()
+  if (scope === 'transaction') {
+    return (d, k) => attributeFilter.filterTransaction(d, k)
+  } else if (scope === 'segment') {
+    return (d, k) => attributeFilter.filterSegment(d, k)
+  }
+}
+
+module.exports = {
+  PrioritizedAttributes: PrioritizedAttributes,
+  ATTRIBUTE_PRIORITY: ATTRIBUTE_PRIORITY
+}

package/lib/serverless/aws-lambda.js

@@ -121,7 +121,10 @@ class AwsLambda {
       transaction.setPartialName(transactionName)
 
       const isApiGatewayLambdaProxy = apiGateway.isLambdaProxyEvent(event)
-
+      const segmentRecorder = isApiGatewayLambdaProxy ? recordWeb : recordBackground
+      const segment = shim.createSegment(functionName, segmentRecorder)
+      transaction.baseSegment = segment
+      
       // resultProcessor is used to execute additional logic based on the
       // payload supplied to the callback.
       let resultProcessor
@@ -131,9 +134,6 @@ class AwsLambda {
         resultProcessor = getApiGatewayLambdaProxyResultProcessor(transaction)
       }
 
-      const segmentRecorder = isApiGatewayLambdaProxy ? recordWeb : recordBackground
-      const segment = shim.createSegment(functionName, segmentRecorder)
-      transaction.baseSegment = segment
 
       const cbIndex = args.length - 1
 
@@ -175,6 +175,8 @@ class AwsLambda {
       shim.agent.setLambdaArn(context.invokedFunctionArn)
 
       shim.agent.setLambdaFunctionVersion(context.functionVersion)
+      
+      segment.addSpanAttributes(awsAttributes)
 
       segment.start()
 
@@ -301,6 +303,8 @@ function getApiGatewayLambdaProxyResultProcessor(transaction) {
 function setWebRequest(shim, transaction, request) {
   transaction.type = shim.WEB
 
+  const segment = transaction.baseSegment
+
   transaction.url = urltils.scrub(request.url.path)
   transaction.verb = request.method
   transaction.trace.attributes.addAttribute(
@@ -308,6 +312,12 @@ function setWebRequest(shim, transaction, request) {
     'request.method',
     request.method
   )
+
+  segment.addSpanAttribute(
+    'request.method',
+    request.method
+  )
+
   transaction.port = request.url.port
 
   transaction.addRequestParameters(request.url.requestParameters)
@@ -319,6 +329,11 @@ function setWebRequest(shim, transaction, request) {
     request.url.path
   )
 
+  segment.addSpanAttribute(
+    'request.uri',
+    request.url.path
+  )
+
   headerAttributes.collectRequestHeaders(request.headers, transaction)
 
   if (shim.agent.config.distributed_tracing.enabled) {
@@ -369,6 +384,10 @@ function setWebResponse(transaction, response) {
   transaction.statusCode = response.statusCode
 
   const responseCode = String(response.statusCode)
+  /*
+  TODO: remove with next major release
+  httpResponseCode attribute is deprecated
+  */
   transaction.trace.attributes.addAttribute(
     ATTR_DEST.TRANS_COMMON,
     'httpResponseCode',
@@ -376,10 +395,24 @@ function setWebResponse(transaction, response) {
   )
 
   if (/^\d+$/.test(responseCode)) {
+    /*
+    TODO: remove with next major release
+    response.status attribute is deprecated
+    */
     transaction.trace.attributes.addAttribute(
       ATTR_DEST.TRANS_COMMON,
       'response.status',
       responseCode)
+
+    transaction.trace.attributes.addAttribute(
+      ATTR_DEST.TRANS_COMMON,
+      'http.statusCode',
+      responseCode
+    )
+
+    const segment = transaction.agent.tracer.getSegment()
+
+    segment.addSpanAttribute('http.statusCode', responseCode)
   }
 
   headerAttributes.collectResponseHeaders(response.headers, transaction)

package/lib/serverless/event-sources.json

@@ -21,7 +21,7 @@
             "httpMethod",
             "path",
             "requestContext",
-            "resource"
+            "requestContext.stage"
         ]
     },
     "cloudFront": {

package/lib/shim/message-shim.js

@@ -750,6 +750,12 @@ function recordSubscribedConsume(nodule, properties, spec) {
               ATTR_DESTS.NONE,
               'message.parameters.' + key,
               msgDesc.parameters[key])
+
+            tx.baseSegment.attributes.addAttribute(
+              ATTR_DESTS.NONE,
+              'message.parameters.' + key,
+              msgDesc.parameters[key]
+            )
           }
         }
 
@@ -762,6 +768,11 @@ function recordSubscribedConsume(nodule, properties, spec) {
               'message.routingKey',
               msgDesc.routingKey
             )
+
+            tx.baseSegment.addSpanAttribute(
+              'message.routingKey',
+              msgDesc.routingKey
+            )
           }
           if (shim.isString(msgDesc.queue)) {
             tx.trace.attributes.addAttribute(
@@ -769,6 +780,11 @@ function recordSubscribedConsume(nodule, properties, spec) {
               'message.queueName',
               msgDesc.queue
             )
+
+            tx.baseSegment.addSpanAttribute(
+              'message.queueName',
+              msgDesc.queue
+            )
           }
         }
         if (msgDesc.headers) {

package/lib/shim/shim.js

@@ -989,9 +989,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. :)
+      // 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) {

package/lib/spans/span-context.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const {MAXIMUM_CUSTOM_ATTRIBUTES} = require('../attributes')
+const {PrioritizedAttributes, ATTRIBUTE_PRIORITY} = require('../prioritized-attributes')
+const {DESTINATIONS} = require('../config/attribute-filter')
+
+// Scoping impacts memoization. We could decide to add a scope instead of including
+// spans in segment scope in the future.
+const ATTRIBUTE_SCOPE = 'segment'
+
+class SpanContext {
+  constructor(intrinsicAttributes, customAttributes) {
+    this.intrinsicAttributes = intrinsicAttributes || Object.create(null)
+
+    this.customAttributes =
+      customAttributes || new PrioritizedAttributes(ATTRIBUTE_SCOPE, MAXIMUM_CUSTOM_ATTRIBUTES)
+
+    this.ATTRIBUTE_PRIORITY = ATTRIBUTE_PRIORITY
+  }
+
+  addIntrinsicAttribute(key, value) {
+    this.intrinsicAttributes[key] = value
+  }
+
+  addCustomAttribute(key, value, priority) {
+    this.customAttributes.addAttribute(
+      DESTINATIONS.SPAN_EVENT,
+      key,
+      value,
+      false,
+      priority
+    )
+  }
+}
+
+module.exports = SpanContext

package/lib/spans/span-event.js

@@ -80,7 +80,9 @@ class SpanEvent {
    */
   static fromSegment(segment, parentId = null, isRoot = false) {
     const attributes = segment.attributes.get(DESTINATIONS.SPAN_EVENT)
-    const customAttributes = segment.customAttributes.get(DESTINATIONS.SPAN_EVENT)
+
+    const spanContext = segment.getSpanContext()
+    const customAttributes = spanContext.customAttributes.get(DESTINATIONS.SPAN_EVENT)
 
     let span = null
     if (HttpSpanEvent.testSegment(segment)) {
@@ -91,6 +93,11 @@ class SpanEvent {
       span = new SpanEvent(attributes, customAttributes)
     }
 
+
+    for (const [key, value] of Object.entries(spanContext.intrinsicAttributes)) {
+      span.intrinsics[key] = value
+    }
+
     const tx = segment.transaction
 
     span.intrinsics.traceId = tx.traceId

package/lib/spans/span-streamer.js

@@ -126,10 +126,11 @@ class SpanStreamer {
     }
   }
 
-  connect(agent_run_id) {
+  connect(agent_run_id, requestHeadersMap) {
     this.connection.setConnectionDetails(
       this.license_key,
-      agent_run_id
+      agent_run_id,
+      requestHeadersMap
     )
 
     this.connection.connectSpans()

package/lib/spans/streaming-span-event-aggregator.js

@@ -31,8 +31,10 @@ class StreamingSpanEventAggregator extends Aggregator {
     }
 
     logger.trace('StreamingSpanEventAggregator starting up')
-    this.stream.connect(this.runId)
+    this.stream.connect(this.runId, this.requestHeadersMap)
     this.started = true
+
+    this.emit('started')
   }
 
   stop() {
@@ -43,6 +45,8 @@ class StreamingSpanEventAggregator extends Aggregator {
     logger.trace('StreamingSpanEventAggregator stopping')
     this.stream.disconnect()
     this.started = false
+
+    this.emit('stopped')
   }
 
   send() {
@@ -83,6 +87,12 @@ class StreamingSpanEventAggregator extends Aggregator {
     const span = StreamingSpanEvent.fromSegment(segment, parentId, isRoot)
     this.stream.write(span)
   }
+
+  reconfigure(config) {
+    super.reconfigure(config)
+
+    this.requestHeadersMap = config.request_headers_map
+  }
 }
 
 module.exports = StreamingSpanEventAggregator

package/lib/spans/streaming-span-event.js

@@ -98,7 +98,9 @@ class StreamingSpanEvent {
 
   static fromSegment(segment, parentId = null, isRoot = false) {
     const agentAttributes = segment.attributes.get(DESTINATIONS.SPAN_EVENT)
-    const customAttributes = segment.customAttributes.get(DESTINATIONS.SPAN_EVENT)
+
+    const spanContext = segment.getSpanContext()
+    const customAttributes = spanContext.customAttributes.get(DESTINATIONS.SPAN_EVENT)
 
     const transaction = segment.transaction
     const traceId = transaction.traceId
@@ -112,6 +114,10 @@ class StreamingSpanEvent {
       span = new StreamingSpanEvent(traceId, agentAttributes, customAttributes)
     }
 
+    for (const [key, value] of Object.entries(spanContext.intrinsicAttributes)) {
+      span.addIntrinsicAttribute(key, value)
+    }
+
     span.addIntrinsicAttribute('guid', segment.id)
     span.addIntrinsicAttribute('parentId', parentId)
     span.addIntrinsicAttribute('transactionId', transaction.id)