newrelic 6.7.0 → 6.10.0

package/NEWS.md

@@ -1,3 +1,86 @@
+### 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.
+
+* Added 'transaction.name' intrinsic to active span at time transaction name is finalized.
+
+  This enables finding transaction name for traces that may not have a matching transaction event.
+
+* Added 'error.expected' attribute to span active at time expected error was noticed.
+
+* Dropped errors earlier during collection when error collection is disabled.
+
+  Error attributes will no longer show up on spans when error collection has been disabled. Other unnecessary work will also be avoided.
+
+* Removed allocation of logging-only objects used by transaction naming when those log levels are disabled.
+
+* Upgraded escodegen from 1.12.0 to 1.14.1.
+
+* Upgraded readable-stream from 3.4.0 to 3.6.0.
+
+* Upgraded @grpc/proto-loader from 0.5.3 to 0.5.4.
+
+* Converted facts unit test to use tap API.
+
+* Converted transaction 'finalizeName...' unit tests to use tap API.
+
+* Added several items to .npmignore to prevent accidental publishing.
+
+* Fixed Redis client w/o callback versioned test flicker.
+
+  Doesn't end transaction until error encountered. Increases wait time for first operation which has to complete for the second operation to be successful.
+
+### 6.8.0 (2020-05-21):
+
+* Bumped @newrelic/native-metrics to ^5.1.0.
+
+  Upgraded nan to ^2.14.1 to resolve 'GetContents' deprecation warning with Node 14. This version of the native metrics module is tested against Node 14 and includes a pre-built binary download backup for Node 14.
+
+* Added whitespace trimming of license key configuration values.
+
+  Previously, when a license key was entered with leading or trailing whitespace, it would be used as-is and result in a validation failure. This most commonly occurred with environment variable based configuration.
+
+* Moved to GitHub actions for CI.
+
+* Updated PR template and added initial issue templates.
+
+* Converted most of the collector API unit tests to use the tap API. Split larger test groupings into their own test files.
+
+### 6.7.1 (2020-05-14):
+
+* Added synthetics headers to transaction event intrinsics for DT
+
+* Fixed stale comment documentation with regards to segment recording
+
 ### 6.7.0 (2020-05-06):
 
 * Added a configurable-length span queue to Infinite Tracing:

package/README.md

@@ -742,3 +742,5 @@ license and the licenses of its dependencies.
 [6]: https://github.com/newrelic/node-newrelic/blob/master/lib/config/default.js
 [7]: https://docs.newrelic.com/docs/agents/nodejs-agent/installation-configuration/nodejs-agent-configuration
 
+
+

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/bin/run-versioned-tests.sh

@@ -21,5 +21,14 @@ fi
 
 export AGENT_PATH=`pwd`
 
+# @koa/router 8.03+ breaks segment naming for nested routes
+skip="koa"
+
+# Don't run the aws-sdk tests if we don't have the keys set
+if [[ -z "$AWS_ACCESS_KEY_ID" ]]; then
+  skip="${skip},aws-sdk"
+fi
+
+
 # This is meant to be temporary. Remove once new major version with fixes rolled into agent.
-time ./node_modules/.bin/versioned-tests $VERSIONED_MODE -i 2 -s koa ${directories[@]}
+time ./node_modules/.bin/versioned-tests $VERSIONED_MODE -i 2 -s $skip ${directories[@]}

package/bin/ssl.sh

@@ -8,7 +8,7 @@ set -x  # be chatty and show the lines we're running
 # that are mysterious and not understood, so let
 # bail early if we detect that's the case
 ENGINE_OPENSSL=`openssl version | awk '{print $(1)}'`
-if [ "$ENGINE_OPENSSL" == "LibreSSL" ]
+if [ "$ENGINE_OPENSSL" = "LibreSSL" ]
 then
     echo "LibreSSL is not supported, please install a stock openssl and \n"
     echo "make sure that openssl binary is in your PATH"
@@ -25,7 +25,7 @@ CERTIFICATE="test/lib/self-signed-test-certificate.crt"
 
 # USAGE: ./bin/ssl.sh clear
 # a sub command to remove all the generated files and start over
-if [ "$1" == "clear" ]
+if [ "$1" = "clear" ]
 then
     rm $SSLKEY
     rm $CACERT
@@ -37,7 +37,7 @@ fi
 
 # if there's already a certificate, then exit, but
 # exit with a success code so build continue
-if [ -a $CERTIFICATE ]; then
+if [ -e $CERTIFICATE ]; then
   exit 0;
 fi
 

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
@@ -1323,6 +1328,10 @@ Config.prototype._canonicalize = function _canonicalize() {
 
   this.serverless_mode.enabled = this.serverless_mode.enabled
     && this.feature_flag.serverless_mode
+
+  if (this.license_key) {
+    this.license_key = this.license_key.trim()
+  }
 }
 
 function _parseCodes(codes) {

package/lib/errors/error-collector.js

@@ -193,6 +193,12 @@ class ErrorCollector {
       return
     }
 
+    const shouldCollectErrors = this._shouldCollectErrors()
+    if (!shouldCollectErrors) {
+      logger.trace('error_collector.enabled is false, dropping application error.')
+      return
+    }
+
     if (errorHelper.shouldIgnoreError(transaction, error, this.config)) {
       logger.trace('Ignoring error')
       return
@@ -223,7 +229,15 @@ class ErrorCollector {
    * @param {Exception}  exception The Exception to be traced.
    */
   addUserError(transaction, error, customAttributes) {
-    if (!error) return
+    if (!error) {
+      return
+    }
+
+    const shouldCollectErrors = this._shouldCollectErrors()
+    if (!shouldCollectErrors) {
+      logger.trace('error_collector.enabled is false, dropping user reported error.')
+      return
+    }
 
     const timestamp = Date.now()
     const exception = new Exception({error, timestamp, customAttributes})
@@ -270,18 +284,6 @@ class ErrorCollector {
       return false
     }
 
-    // allow enabling & disabling the error tracer at runtime
-    // TODO: it would be better to check config in the public add() to prevents collecting
-    // errors on the transaction unnecessarily. Should we allow the work above or
-    // short-circuit sooner?
-    if (
-      !this.config.collect_errors ||
-      !this.config.error_collector ||
-      !this.config.error_collector.enabled
-    ) {
-      return false
-    }
-
     if (exception.error) {
       logger.trace(exception.error, 'Got exception to trace:')
     }
@@ -304,7 +306,10 @@ class ErrorCollector {
       }
     }
 
-    this.traceAggregator.add(errorTrace)
+    // defaults true in config/index. can be modified server-side
+    if (this.config.collect_errors) {
+      this.traceAggregator.add(errorTrace)
+    }
 
     if (this.config.error_collector.capture_events === true) {
       const priority = transaction && transaction.priority || Math.random()
@@ -328,6 +333,17 @@ class ErrorCollector {
     this.seenObjectsByTransaction = Object.create(null)
   }
 
+  _shouldCollectErrors() {
+    const errorCollectorEnabled =
+      this.config.error_collector && this.config.error_collector.enabled
+
+    const shouldCaptureTraceOrEvent =
+      this.config.collect_errors || // are traces enabled
+      (this.config.error_collector && this.config.error_collector.capture_events)
+
+    return errorCollectorEnabled && shouldCaptureTraceOrEvent
+  }
+
   reconfigure(config) {
     this.config = config
 

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