newrelic 6.9.0 → 6.10.0

package/NEWS.md

@@ -1,3 +1,32 @@
+### 6.10.0 (2020-06-22):
+
+* Additional Transaction Information applied to Span Events
+  * When Distributed Tracing and/or Infinite Tracing are enabled, the Agent will now incorporate additional information from the Transaction Event on to the currently available Span Event of the transaction.
+    * The following items are affected:
+      * `aws-lambda` related attributes
+      * `error.message`
+      * `error.class`
+      * `error.expected`
+      * `http.statusCode`
+      * `http.statusText`
+      * `message.*`
+      * `parent.type`
+      * `parent.app`
+      * `parent.account`
+      * `parent.transportType`
+      * `parent.transportDuration`
+      * Request Parameters `request.parameters.*`
+      * `request.header.*`
+      * `request.method`
+      * `request.uri`
+  * Custom Attributes
+    * Custom transaction attributes added via `API.addCustomAttribute` or `API.addCustomAttributes` will now be propagated to the currently active span, if available.
+  * **Security Recommendation:**
+    * Review your Transaction Event attributes configuration. Any attribute include or exclude setting specific to Transaction Events should be applied to your Span Attributes configuration or global attributes configuration. Please see [Node.js agent attributes](https://docs.newrelic.com/docs/agents/nodejs-agent/attributes/nodejs-agent-attributes#configure-attributes) for more on how to configure.
+* Upgraded @grpc/grpc-js from 1.0.3 to 1.0.4
+* Modified redis callback-less versioned test to use `commandQueueLength` as indicator redis command has completed and test can continue. This is in effort to further reduce these test flickers. Additionally, added wait for client 'ready' before moving on to tests.
+* Updated force secret test runs to run on branch pushes to the main repository.
+
 ### 6.9.0 (2020-06-08):
 
 * Added AWS API Gateway V2 Support to lambda instrumentation.

package/THIRD_PARTY_NOTICES.md

@@ -18,6 +18,8 @@ can be found at https://github.com/newrelic/node-newrelic.
 * [json-stringify-safe](#json-stringify-safe)
 * [readable-stream](#readable-stream)
 * [semver](#semver)
+* [@grpc/grpc-js](#@grpc/grpc-js)
+* [@grpc/proto-loader](#@grpc/proto-loader)
 
 ## async
 

package/api.js

@@ -272,7 +272,7 @@ API.prototype.setControllerName = function setControllerName(name, action) {
  * @param {string} value The value you want displayed. Must be serializable.
  */
 API.prototype.addCustomAttribute = function addCustomAttribute(key, value) {
-  var metric = this.agent.metrics.getOrCreateMetric(
+  const metric = this.agent.metrics.getOrCreateMetric(
     NAMES.SUPPORTABILITY.API + '/addCustomAttribute'
   )
   metric.incrementCallCount()
@@ -291,24 +291,36 @@ API.prototype.addCustomAttribute = function addCustomAttribute(key, value) {
     return false
   }
 
-  var transaction = this.agent.tracer.getTransaction()
+  const transaction = this.agent.tracer.getTransaction()
   if (!transaction) {
-    return logger.warn('No transaction found for custom attributes.')
+    logger.warn('No transaction found for custom attributes.')
+    return false
   }
 
-  var trace = transaction.trace
+  const trace = transaction.trace
   if (!trace.custom) {
-    return logger.warn(
+    logger.warn(
       'Could not add attribute %s to nonexistent custom attributes.',
       key
     )
+    return false
   }
 
   if (CUSTOM_DENYLIST.has(key)) {
-    return logger.warn('Not overwriting value of NR-only attribute %s.', key)
+    logger.warn('Not overwriting value of NR-only attribute %s.', key)
+    return false
   }
 
   trace.addCustomAttribute(key, value)
+
+  const spanContext = this.agent.tracer.getSpanContext()
+  if (!spanContext) {
+    logger.debug('No span found for custom attributes.')
+    // success/failure is ambiguous here. since at least 1 attempt tried, not returning false
+    return
+  }
+
+  spanContext.addCustomAttribute(key, value, spanContext.ATTRIBUTE_PRIORITY.LOW)
 }
 
 /**
@@ -395,20 +407,22 @@ API.prototype.addCustomSpanAttribute = function addCustomSpanAttribute(key, valu
     return false
   }
 
-  const segment = this.agent.tracer.getSegment()
+  const spanContext = this.agent.tracer.getSpanContext()
 
-  if (!segment) {
-    return logger.debug(
-      'Could not add attribute %s. No available span/segment.',
+  if (!spanContext) {
+    logger.debug(
+      'Could not add attribute %s. No available span.',
       key
     )
+    return false
   }
 
   if (CUSTOM_DENYLIST.has(key)) {
-    return logger.warn('Not overwriting value of NR-only attribute %s.', key)
+    logger.warn('Not overwriting value of NR-only attribute %s.', key)
+    return false
   }
 
-  segment.addCustomSpanAttribute(key, value)
+  spanContext.addCustomAttribute(key, value)
 }
 
 API.prototype.setIgnoreTransaction = util.deprecate(

package/lib/config/index.js

@@ -281,6 +281,11 @@ Config.prototype._fromServer = function _fromServer(params, key) {
       this.run_id = params.agent_run_id
       break
 
+    // if it's undefined or null, so be it
+    case 'request_headers_map':
+      this.request_headers_map = params.request_headers_map
+      break
+
     // handled by config.onConnect
     case 'high_security':
       break

package/lib/grpc/connection.js

@@ -19,10 +19,7 @@ const protoOptions = {keepCase: true,
 const pathProtoDefinition = __dirname +
   '../../../lib/grpc/endpoints/infinite-tracing/v1.proto'
 
-const defaultBackoffOpts = {
-  initialSeconds: 0,
-  seconds:15
-}
+const DEFAULT_RECONNECT_DELAY_MS = 15 * 1000
 
 /**
  * Class for managing the GRPC connection
@@ -41,31 +38,21 @@ class GrpcConnection extends EventEmitter {
    *
    * @param {Object} traceObserverConfig config item config.infinite_tracing.trace_observer
    * @param {MetricAggregator} metrics metric aggregator, for supportability metrics
-   * @param {Object} backoffOpts allows injecting specific backoff times
+   * @param {Number} [reconnectDelayMs=15000] number of milliseconds to wait before reconnecting
+   * for error states that require a reconnect delay.
    */
-  constructor(traceObserverConfig, metrics, backoffOpts = defaultBackoffOpts) {
+  constructor(traceObserverConfig, metrics, reconnectDelayMs) {
     super()
 
-    // only set opts if the object is valid
-    if ( (backoffOpts.initialSeconds || backoffOpts.initialSeconds === 0) &&
-         (backoffOpts.seconds || backoffOpts.seconds === 0)) {
-      this._backoffOpts = backoffOpts
-    } else {
-      this._backoffOpts = defaultBackoffOpts
-      logger.trace(
-        'invalid backoff information passed to constructor, using default values'
-      )
-    }
+    this._reconnectDelayMs = reconnectDelayMs || DEFAULT_RECONNECT_DELAY_MS
 
-    // initial "stream connection" has a 0 second backoff, unless
-    // different values are injected via _backoffOpts
-    this._streamBackoffSeconds = this._backoffOpts.initialSeconds
     this._metrics = metrics
     this._setState(connectionStates.disconnected)
 
     this._endpoint = this.getTraceObserverEndpoint(traceObserverConfig)
     this._licensekey = null
     this._runId = null
+    this._requestHeadersMap = null
 
     this.stream = null
   }
@@ -79,11 +66,13 @@ class GrpcConnection extends EventEmitter {
    * @param {string} endpoint the GRPC server's endpoint
    * @param {string} license_key the agent license key
    * @param {string} run_id the current agent run id (also called agent run token)
+   * @param {object} requestHeadersMap request headers map received from server connect.
    * @param {string} [rootCerts] string of root (ca) certificates to attach to the connection.
    */
-  setConnectionDetails(license_key, run_id, rootCerts) {
+  setConnectionDetails(license_key, run_id, requestHeadersMap, rootCerts) {
     this._licenseKey = license_key
     this._runId = run_id
+    this._requestHeadersMap = requestHeadersMap
     this._rootCerts = rootCerts
 
     return this
@@ -118,35 +107,21 @@ class GrpcConnection extends EventEmitter {
     }
 
     this._setState(connectionStates.connecting)
-    logger.trace('connecting to grpc endpoint in [%s] seconds', this._getBackoffSeconds())
-
-    setTimeout(() => {
-      try {
-        this.stream = this._connectSpans(this._endpoint, this._licenseKey, this._runId)
+    logger.trace('Connecting to gRPC endpoint.')
 
-        // May not actually be "connected" at this point but we can write to the stream
-        // immediately.
-        this._setState(connectionStates.connected, this.stream)
+    try {
+      this.stream = this._connectSpans()
 
-        // any future stream connect/disconnect after initial connection
-        // should have a 15 second backoff
-        this._setStreamBackoffAfterInitialStreamSetup()
-      } catch (err) {
-        logger.trace(
-          err,
-          'Unexpected error establishing GRPC stream, will not attempt reconnect.'
-        )
-        this._disconnectWithoutReconnect()
-      }
-    }, this._getBackoffSeconds() * 1000)
-  }
-
-  _setStreamBackoffAfterInitialStreamSetup() {
-    this._streamBackoffSeconds = this._backoffOpts.seconds
-  }
-
-  _setStreamBackoffToInitialValue() {
-    this._streamBackoffSeconds = this._backoffOpts.initialSeconds
+      // May not actually be "connected" at this point but we can write to the stream
+      // immediately.
+      this._setState(connectionStates.connected, this.stream)
+    } catch (err) {
+      logger.trace(
+        err,
+        'Unexpected error establishing gRPC stream, will not attempt reconnect.'
+      )
+      this._disconnect()
+    }
   }
 
   /**
@@ -159,14 +134,7 @@ class GrpcConnection extends EventEmitter {
       return
     }
 
-    this._disconnectWithoutReconnect()
-  }
-
-  /**
-   * Calculates backoff seconds
-   */
-  _getBackoffSeconds() {
-    return this._streamBackoffSeconds
+    this._disconnect()
   }
 
   /**
@@ -175,11 +143,19 @@ class GrpcConnection extends EventEmitter {
    * @param {string} license_key
    * @param {string} run_id
    */
-  _getMetadata(license_key, run_id, env) {
+  _getMetadata(license_key, run_id, requestHeadersMap, env) {
     const metadata = new grpc.Metadata()
     metadata.add('license_key', license_key)
     metadata.add('agent_run_token', run_id)
 
+    // p17 spec: If request_headers_map is empty or absent,
+    // the agent SHOULD NOT apply anything to its requests.
+    if (requestHeadersMap) {
+      for (const [key, value] of Object.entries(requestHeadersMap)) {
+        metadata.add(key.toLowerCase(), value) // keys MUST be lowercase for Infinite Tracing
+      }
+    }
+
     // check environment variables for testing parameters and
     // pass to server via meta-data.
     const flaky = parseInt(env.NEWRELIC_GRPCCONNECTION_METADATA_FLAKY, 10)
@@ -197,18 +173,23 @@ class GrpcConnection extends EventEmitter {
   }
 
   /**
-   * Sets internal object state to disconnected initiates a new connection
-   *
-   * Called when we receive a stream status that indicates a potential
-   * problem with the stream.  We set the state (which will emit an event),
-   * increment tries to honor the backoff, and then reconnect.
+   * Disconnects from gRPC endpoint and schedules establishing a new connection.
+   * @param {number} reconnectDelayMs number of milliseconds to wait before reconnecting.
    */
-  _reconnect() {
+  _reconnect(reconnectDelayMs = 0) {
     this._disconnect()
-    this.connectSpans()
+
+    logger.trace('Reconnecting to gRPC endpoint in [%s] seconds', reconnectDelayMs)
+
+    setTimeout(
+      this.connectSpans.bind(this),
+      reconnectDelayMs
+    )
   }
 
   _disconnect() {
+    logger.trace('Disconnecting from gRPC endpoint.')
+
     if (this.stream) {
       this.stream.removeAllListeners()
 
@@ -221,17 +202,6 @@ class GrpcConnection extends EventEmitter {
     this._setState(connectionStates.disconnected)
   }
 
-  /**
-   * Disconnects Without Reconnect
-   *
-   * Certain GRPC statuses require us to disconnect and _not_
-   * attempt a stream reconnect.
-   */
-  _disconnectWithoutReconnect() {
-    this._disconnect()
-    this._setStreamBackoffToInitialValue()
-  }
-
   /**
    * Central location to setup stream observers
    *
@@ -244,14 +214,14 @@ class GrpcConnection extends EventEmitter {
     // listen for responses from server and log
     if (logger.traceEnabled()) {
       stream.on('data', function data(response) {
-        logger.trace("grpc span response stream: %s", JSON.stringify(response))
+        logger.trace("gRPC span response stream: %s", JSON.stringify(response))
       })
     }
 
     // listen for status that indicate stream has ended,
     // and we need to disconnect
     stream.on('status', (grpcStatus) => {
-      logger.trace('GRPC Status Received [%s]: %s', grpcStatus.code, grpcStatus.details)
+      logger.trace('gRPC Status Received [%s]: %s', grpcStatus.code, grpcStatus.details)
       const grpcStatusName =
         grpc.status[grpcStatus.code] ? grpc.status[grpcStatus.code] : 'UNKNOWN'
 
@@ -263,19 +233,15 @@ class GrpcConnection extends EventEmitter {
         // per the spec, An UNIMPLEMENTED status code from gRPC indicates
         // that the versioned Trace Observer is no longer available. Agents
         // MUST NOT attempt to reconnect in this case
-        this._disconnectWithoutReconnect()
+        this._disconnect()
+      } else if (grpc.status[grpc.status.OK] === grpcStatusName) {
+        this._reconnect()
       } else {
-        // all statuses are treated as "bad stuff" happened, and
-        // as a signal we need to reconnect (except UNIMPLEMENTED).
-        // Even an "OK status" indicates the call completed successfully,
-        // which indicates the stream is over.
-        if (grpc.status[grpc.status.OK] !== grpcStatusName) {
-          this._metrics.getOrCreateMetric(
-            util.format(NAMES.INFINITE_TRACING.SPAN_RESPONSE_GRPC_STATUS, grpcStatusName)
-          ).incrementCallCount()
-        }
+        this._metrics.getOrCreateMetric(
+          util.format(NAMES.INFINITE_TRACING.SPAN_RESPONSE_GRPC_STATUS, grpcStatusName)
+        ).incrementCallCount()
 
-        this._reconnect()
+        this._reconnect(this._reconnectDelayMs)
       }
     })
 
@@ -322,7 +288,7 @@ class GrpcConnection extends EventEmitter {
    * this makes an http2 request with the metadata, and then returns
    * a stream for further writing.
    */
-  _connectSpans(endpoint, license_key, run_id) {
+  _connectSpans() {
     const packageDefinition = protoLoader.loadSync(pathProtoDefinition, protoOptions)
 
     const serviceDefinition = grpc.loadPackageDefinition(
@@ -331,14 +297,18 @@ class GrpcConnection extends EventEmitter {
 
     const credentials = this._generateCredentials(grpc)
     const client = new serviceDefinition.IngestService(
-      endpoint,
+      this._endpoint,
       credentials
     )
-    const metadata = this._getMetadata(license_key, run_id, process.env)
+
+    const metadata =
+      this._getMetadata(this._licenseKey, this._runId, this._requestHeadersMap, process.env)
+
     const stream = client.recordSpan(metadata)
     this._setupSpanStreamObservers(stream)
 
     return stream
   }
 }
+
 module.exports = GrpcConnection

package/lib/header-attributes.js

@@ -110,6 +110,8 @@ function _collectHeaders(headers, nameMap, prefix, transaction) {
     ? COLLECTED_REQUEST_HEADERS
     : Object.keys(headers)
 
+  const segment = transaction.agent.tracer.getSegment()
+  
   for (var i = 0; i < headerKeys.length; i++) {
     var headerKey = headerKeys[i]
     var header = headers[headerKey]
@@ -128,6 +130,8 @@ function _collectHeaders(headers, nameMap, prefix, transaction) {
         attributeName,
         header
       )
+
+      segment.addSpanAttribute(attributeName, header)
     }
   }
 }

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

@@ -133,7 +133,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
     if (parsed.parameters) {
       // Scrub and parse returns on object with a null prototype.
       for (let key in parsed.parameters) { // eslint-disable-line guard-for-in
-        segment.addAttribute(`request.parameters.${key}`, parsed.parameters[key])
+        segment.addSpanAttribute(`request.parameters.${key}`, parsed.parameters[key])
       }
     }
     segment.addAttribute('url', `${proto}//${hostname}${parsed.path}`)
@@ -196,8 +196,8 @@ function handleError(segment, req, error) {
  */
 function handleResponse(segment, hostname, req, res) {
   // Add response attributes for spans
-  segment.addAttribute('http.statusCode', res.statusCode)
-  segment.addAttribute('http.statusText', res.statusMessage)
+  segment.addSpanAttribute('http.statusCode', res.statusCode)
+  segment.addSpanAttribute('http.statusText', res.statusMessage)
   
   // If CAT is enabled, grab those headers!
   const agent = segment.transaction.agent

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()
@@ -172,6 +184,8 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
               'http.statusCode',
               responseCode
             )
+              
+            segment.addSpanAttribute('http.statusCode', responseCode)
 
             /*
             TODO: remove with next major release
@@ -192,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/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/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/spans/span-context.js

@@ -1,13 +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) {
+  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,7 +93,7 @@ class SpanEvent {
       span = new SpanEvent(attributes, customAttributes)
     }
 
-    const spanContext = segment.getSpanContext()
+
     for (const [key, value] of Object.entries(spanContext.intrinsicAttributes)) {
       span.intrinsics[key] = value
     }

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,7 +114,6 @@ class StreamingSpanEvent {
       span = new StreamingSpanEvent(traceId, agentAttributes, customAttributes)
     }
 
-    const spanContext = segment.getSpanContext()
     for (const [key, value] of Object.entries(spanContext.intrinsicAttributes)) {
       span.addIntrinsicAttribute(key, value)
     }

package/lib/transaction/index.js

@@ -406,6 +406,20 @@ function finalizeNameFromUri(requestURL, statusCode) {
             'request.parameters.' + key,
             params[key]
           )
+
+          const segment = this.agent.tracer.getSegment()
+
+          if (!segment) {
+            logger
+              .trace('Active segment not available, not adding request.parameters attribute for %s',
+                key)
+          } else {
+            segment.attributes.addAttribute(
+              DESTS.NONE,
+              'request.parameters.' + key,
+              params[key]
+            )
+          }
         }
       }
     }, this)
@@ -466,6 +480,21 @@ Transaction.prototype._markAsWeb = function _markAsWeb(rawURL) {
         'request.parameters.' + key,
         params[key]
       )
+
+      const segment = this.agent.tracer.getSegment()
+
+      if (!segment) {
+        logger
+          .trace(
+            'Active segment not available, not adding request.parameters span attribute for %s',
+            key)
+      } else {
+        segment.attributes.addAttribute(
+          DESTS.NONE,
+          'request.parameters.' + key,
+          params[key]
+        )
+      }
     }
   }
   this.baseSegment.markAsWeb()
@@ -717,15 +746,15 @@ function _linkExceptionToSegment(exception) {
 
   // Add error attributes to the span
   const details = exception.getErrorDetails(config)
-  segment.addAttribute('error.message', details.message)
-  segment.addAttribute('error.class', details.type)
+  segment.addSpanAttribute('error.message', details.message)
+  segment.addSpanAttribute('error.class', details.type)
 
   const isExpected =
     errorHelper.isExpectedErrorClass(config, details.type) ||
     errorHelper.isExpectedErrorMessage(config, details.type, details.message)
 
   if (isExpected) {
-    segment.addAttribute('error.expected', isExpected)
+    segment.addSpanAttribute('error.expected', isExpected)
   }
 
   // Add the span/segment ID to the exception as agent attributes
@@ -1264,6 +1293,14 @@ function addRequestParameters(requestParameters) {
         'request.parameters.' + key,
         requestParameters[key]
       )
+
+      const segment = this.baseSegment
+
+      segment.attributes.addAttribute(
+        DESTS.NONE,
+        'request.parameters.' + key,
+        requestParameters[key]
+      )
     }
   }
 }

package/lib/transaction/trace/index.js

@@ -41,6 +41,8 @@ function Trace(transaction) {
       'host.displayName',
       displayName
     )
+
+    this.displayName = displayName
   }
   this.domain = null
 }
@@ -82,6 +84,26 @@ Trace.prototype.generateSpanEvents = function generateSpanEvents() {
     const spanAggregator = this.transaction.agent.spanEventAggregator
 
     const children = this.root.getChildren()
+
+    if (children.length > 0) {
+      // At the point where these attributes are available, we only have a
+      // root span. Adding attributes to first non-root span here.
+      const attributeMap = {
+        'host.displayName': this.displayName,
+        'parent.type': this.transaction.parentType,
+        'parent.app': this.transaction.parentApp,
+        'parent.account': this.transaction.parentAcct,
+        'parent.transportType': this.transaction.parentTransportType,
+        'parent.transportDuration': this.transaction.parentTransportDuration
+      }
+
+      for (const [key, value] of Object.entries(attributeMap)) {
+        if (value !== null) {
+          children[0].addSpanAttribute(key, value)
+        }
+      }
+    }
+
     for (let i = 0; i < children.length; ++i) {
       toProcess.push(new DTTraceNode(children[i], this.transaction.parentSpanId, true))
     }

package/lib/transaction/trace/segment.js

@@ -6,7 +6,7 @@ const Timer = require('../../timer')
 const urltils = require('../../util/urltils')
 const hashes = require('../../util/hashes')
 
-const {Attributes, MAXIMUM_CUSTOM_ATTRIBUTES} = require('../../attributes')
+const {Attributes} = require('../../attributes')
 const ExclusiveCalculator = require('./exclusive-time-calculator')
 const SpanContext = require('../../spans/span-context')
 
@@ -53,7 +53,6 @@ function TraceSegment(transaction, name, recorder) {
   }
 
   this.attributes = new Attributes(ATTRIBUTE_SCOPE)
-  this.customAttributes = new Attributes(ATTRIBUTE_SCOPE, MAXIMUM_CUSTOM_ATTRIBUTES)
 
   this.children = []
 
@@ -99,13 +98,9 @@ function addAttribute(key, value, truncateExempt = false) {
   )
 }
 
-TraceSegment.prototype.getAttributes = function getAttributes() {
-  return this.attributes.get(DESTINATIONS.TRANS_SEGMENT)
-}
-
-TraceSegment.prototype.addCustomSpanAttribute =
-function addCustomSpanAttribute(key, value, truncateExempt = false) {
-  this.customAttributes.addAttribute(
+TraceSegment.prototype.addSpanAttribute =
+function addSpanAttribute(key, value, truncateExempt = false) {
+  this.attributes.addAttribute(
     DESTINATIONS.SPAN_EVENT,
     key,
     value,
@@ -113,6 +108,18 @@ function addCustomSpanAttribute(key, value, truncateExempt = false) {
   )
 }
 
+TraceSegment.prototype.addSpanAttributes =
+function addSpanAttributes(attributes) {
+  this.attributes.addAttributes(
+    DESTINATIONS.SPAN_EVENT,
+    attributes
+  )
+}
+
+TraceSegment.prototype.getAttributes = function getAttributes() {
+  return this.attributes.get(DESTINATIONS.TRANS_SEGMENT)
+}
+
 TraceSegment.prototype.getSpanId = function getSpanId() {
   const conf = this.transaction.agent.config
   const enabled = conf.span_events.enabled && conf.distributed_tracing.enabled

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "6.9.0",
+  "version": "6.10.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "SEE LICENSE IN LICENSE",
   "contributors": [
@@ -142,7 +142,7 @@
     "newrelic-naming-rules": "./bin/test-naming-rules.js"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.0.3",
+    "@grpc/grpc-js": "1.0.4",
     "@grpc/proto-loader": "^0.5.4",
     "@newrelic/aws-sdk": "^1.1.1",
     "@newrelic/koa": "^3.0.0",