newrelic 8.16.0 → 8.17.0

package/NEWS.md

@@ -1,3 +1,7 @@
+### v8.17.0 (2022-07-27)
+
+* Added instrumentation for `grpc-js` server unary, client-streaming, server-streaming and bidirectional streaming handlers.
+
 ### v8.16.0 (2022-07-21)
 
 * Automatic application log forwarding is now enabled by default. This version of the agent will automatically send enriched application logs to New Relic. To learn more about about this feature, see the [APM logs in context documentation](https://docs.newrelic.com/docs/apm/new-relic-apm/getting-started/get-started-logs-context/). For additional configuration options, see the [Node.js logs in context documentation](https://docs.newrelic.com/docs/logs/logs-context/configure-logs-context-nodejs). To learn about how to toggle log ingestion on or off by account, see our documentation to [disable automatic logging](https://docs.newrelic.com/docs/logs/logs-context/disable-automatic-logging) via the UI or API.

package/lib/config/default.js

@@ -770,6 +770,18 @@ exports.config = () => ({
     database_name_reporting: { enabled: true }
   },
 
+  /**
+   * Controls behavior of gRPC server instrumentation.
+   */
+  grpc: {
+    /**
+     * Enables recording of non-zero gRPC status codes. Default is `true`.
+     *
+     * @env NEW_RELIC_GRPC_RECORD_ERRORS
+     */
+    record_errors: true
+  },
+
   /**
    * Controls the behavior of span events produced by the agent.
    */

package/lib/config/env.js

@@ -123,6 +123,9 @@ const ENV_MAPPING = {
       enabled: 'NEW_RELIC_DATASTORE_DATABASE_NAME_REPORTING_ENABLED'
     }
   },
+  grpc: {
+    record_errors: 'NEW_RELIC_GRPC_RECORD_ERRORS'
+  },
   span_events: {
     enabled: 'NEW_RELIC_SPAN_EVENTS_ENABLED',
     attributes: {
@@ -240,6 +243,7 @@ const BOOLEAN_VARS = new Set([
   'NEW_RELIC_BROWSER_MONITOR_DEBUG',
   'NEW_RELIC_HIGH_SECURITY',
   'NEW_RELIC_SLOW_SQL_ENABLED',
+  'NEW_RELIC_GRPC_RECORD_ERRORS',
   'NEW_RELIC_SPAN_EVENTS_ENABLED',
   'NEW_RELIC_SPAN_EVENTS_ATTRIBUTES_ENABLED',
   'NEW_RELIC_DISTRIBUTED_TRACING_ENABLED',

package/lib/instrumentation/grpc-js/grpc.js

@@ -6,80 +6,215 @@
 'use strict'
 
 const recordExternal = require('../../metrics/recorders/http_external')
+const recordHttp = require('../../metrics/recorders/http')
+const { DESTINATIONS } = require('../../config/attribute-filter')
+const DESTINATION = DESTINATIONS.TRANS_EVENT | DESTINATIONS.ERROR_EVENT
+const semver = require('semver')
 
 module.exports = function instrument(shim) {
-  const callStream = shim.require('./build/src/call-stream')
-  shim.wrap(callStream.Http2CallStream.prototype, 'start', (shim, original) => {
-    return function wrappedStart() {
-      const activeSegment = shim.getActiveSegment()
-      if (!activeSegment) {
-        return original.apply(this, arguments)
-      }
+  const genericShim = shim.makeSpecializedShim(shim.GENERIC, 'call-stream')
+  const callStream = genericShim.require('./build/src/call-stream')
+  genericShim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
+
+  const webFrameworkShim = shim.makeSpecializedShim(shim.WEB_FRAMEWORK, 'server')
+  const server = webFrameworkShim.require('./build/src/server')
+  webFrameworkShim.setFramework('gRPC')
+  webFrameworkShim.wrap(server.Server.prototype, 'register', wrapRegister)
+}
+
+/**
+ * Instruments grpc-js client by intercepting the function that
+ * initiates client requests. This handles all four types of client
+ * invocations: unary, client-streaming, server-streaming, and
+ * bidirectional streaming.
+ *
+ * @param {object} shim the generic shim to instrument with
+ * @param {Function} original the original function
+ * @returns {Function} the instrumented function
+ */
+function wrapStart(shim, original) {
+  return function wrappedStart() {
+    const activeSegment = shim.getActiveSegment()
+    if (!activeSegment) {
+      return original.apply(this, arguments)
+    }
 
-      const channel = this.channel
-      const authorityName = (channel.target && channel.target.path) || channel.getDefaultAuthority
+    const channel = this.channel
+    const authorityName = (channel.target && channel.target.path) || channel.getDefaultAuthority
 
-      const segment = shim.createSegment({
-        name: `External/${authorityName}${this.methodName}`,
-        opaque: true,
-        recorder: recordExternal(authorityName, 'gRPC')
-      })
+    const segment = shim.createSegment({
+      name: `External/${authorityName}${this.methodName}`,
+      opaque: true,
+      recorder: recordExternal(authorityName, 'gRPC')
+    })
 
-      return shim.applySegment(callStart, segment, true, this, arguments)
+    return shim.applySegment(callStart, segment, true, this, arguments)
+
+    function callStart() {
+      const args = shim.argsToArray.apply(shim, arguments)
+
+      const transaction = segment.transaction
+
+      const originalMetadata = args[0]
+      const nrMetadata = originalMetadata.clone()
+
+      const outboundAgentHeaders = Object.create(null)
+      if (shim.agent.config.distributed_tracing.enabled) {
+        transaction.insertDistributedTraceHeaders(outboundAgentHeaders)
+        Object.keys(outboundAgentHeaders).forEach((key) => {
+          nrMetadata.add(key, outboundAgentHeaders[key])
+        })
+      } else {
+        shim.logger.debug('Distributed tracing disabled by instrumentation.')
+      }
 
-      function callStart() {
-        const args = shim.argsToArray.apply(shim, arguments)
+      args[0] = nrMetadata
 
-        const transaction = segment.transaction
+      const originalListener = args[1]
+      const nrListener = Object.assign({}, originalListener)
+      nrListener.onReceiveStatus = (status) => {
+        const { code, details } = status
 
-        const originalMetadata = args[0]
-        const nrMetadata = originalMetadata.clone()
+        segment.addAttribute('grpc.statusCode', code)
+        segment.addAttribute('grpc.statusText', details)
 
-        const outboundAgentHeaders = Object.create(null)
-        if (shim.agent.config.distributed_tracing.enabled) {
-          transaction.insertDistributedTraceHeaders(outboundAgentHeaders)
-          Object.keys(outboundAgentHeaders).forEach((key) => {
-            nrMetadata.add(key, outboundAgentHeaders[key])
-          })
-        } else {
-          shim.logger.debug('Distributed tracing disabled by instrumentation.')
+        // Java captures client errors based on status code
+        // but has specific gRPC configuration to turn off
+        if (code !== 0) {
+          // this is currently just creating an error from the details string
+          shim.agent.errors.add(segment.transaction, details)
         }
 
-        args[0] = nrMetadata
+        segment.addAttribute('component', 'gRPC')
 
-        const originalListener = args[1]
-        const nrListener = Object.assign({}, originalListener)
-        nrListener.onReceiveStatus = (status) => {
-          const { code, details } = status
+        const protocol = 'grpc'
 
-          segment.addAttribute('grpc.statusCode', code)
-          segment.addAttribute('grpc.statusText', details)
+        const url = `${protocol}://${authorityName}${this.methodName}`
 
-          // Java captures client errors based on status code
-          // but has specific gRPC configuration to turn off
-          if (code !== 0) {
-            // this is currently just creating an error from the details string
-            shim.agent.errors.add(segment.transaction, details)
-          }
+        segment.addAttribute('http.url', url)
+        segment.addAttribute('http.method', this.methodName)
 
-          segment.addAttribute('component', 'gRPC')
+        segment.end()
 
-          const protocol = 'grpc'
+        originalListener && originalListener.onReceiveStatus(status)
+      }
 
-          const url = `${protocol}://${authorityName}${this.methodName}`
+      args[1] = nrListener
 
-          segment.addAttribute('http.url', url)
-          segment.addAttribute('http.method', this.methodName)
+      return original.apply(this, args)
+    }
+  }
+}
 
-          segment.end()
+/**
+ * Instruments the grpc-js server by intercepting the moment when
+ * server methods are registered from the method implementations
+ * provided to grpc-js. This handles all four types of server
+ * invocations: unary, client-streaming, server-streaming, and
+ * bidirectional streaming.
+ *
+ * @param {object} shim the web shim to instrument with
+ * @param {Function} original the original function
+ * @returns {Function} the instrumented function
+ */
+function wrapRegister(shim, original) {
+  const constants = shim.require('./build/src/constants')
 
-          originalListener && originalListener.onReceiveStatus(status)
-        }
+  return function wrappedRegister() {
+    const args = shim.argsToArray.apply(shim, arguments)
 
-        args[1] = nrListener
+    const name = args[0]
+    const handler = args[1]
+    const type = args[args.length - 1]
 
-        return original.apply(this, args)
-      }
+    if (this.handlers.has(name)) {
+      shim.logger.debug(
+        `Not re-instrumenting gRPC method handler for ${name}: it is already registered in the server.`
+      )
+      return original.apply(this, arguments)
+    }
+
+    args[1] = shim.bindCreateTransaction(instrumentedHandler, { type: shim.WEB })
+
+    return original.apply(this, args)
+
+    function instrumentedHandler(stream) {
+      const { transaction, segment } = createTransaction()
+      acceptDTHeaders(stream, transaction)
+      instrumentEventListeners(stream, transaction)
+      return shim.applySegment(handler, segment, true, this, arguments)
     }
-  })
+
+    function createTransaction() {
+      const parent = shim.getActiveSegment()
+      const transaction = parent.transaction
+
+      // Create the transaction segment using the request URL for now. Once a
+      // better name can be determined this segment will be renamed to that.
+      const segment = shim.createSegment(name, recordHttp)
+      segment.start()
+
+      transaction.type = 'web'
+      transaction.baseSegment = segment
+      transaction.url = name
+
+      transaction.trace.attributes.addAttribute(DESTINATION, 'request.method', transaction.url)
+
+      transaction.trace.attributes.addAttribute(DESTINATION, 'request.uri', transaction.url)
+
+      shim.setTransactionUri(transaction.url)
+
+      // This attribute isn't required by the spec, but it seems useful to have
+      transaction.trace.attributes.addAttribute(DESTINATION, 'grpc.type', type)
+      return { transaction, segment }
+    }
+
+    function acceptDTHeaders(stream, transaction) {
+      const metadata = stream.metadata
+      Object.entries(metadata.getMap()).forEach(([key, value]) => {
+        transaction.trace.attributes.addAttribute(DESTINATION, `request.headers.${key}`, value)
+      })
+
+      const headers = Object.create(null)
+      headers.tracestate = metadata.get('tracestate').join(',')
+      headers.traceparent = metadata.get('traceparent').join(',')
+      headers.newrelic = metadata.get('newrelic').join(',')
+      transaction.acceptDistributedTraceHeaders('HTTP', headers)
+    }
+
+    function instrumentEventListeners(stream, transaction) {
+      const agent = shim.agent
+      stream.call.once('callEnd', (statusCode) => {
+        transaction.trace.attributes.addAttribute(DESTINATION, 'response.status', statusCode)
+        if (statusCode !== 0 && agent.config.grpc.record_errors) {
+          const status = constants.Status[statusCode]
+          const error = new Error(`gRPC status code ${statusCode}: ${status}`)
+          agent.errors.add(transaction, error)
+        }
+      })
+      stream.call.once('streamEnd', () => {
+        transaction.end()
+      })
+      // TODO should also instrument the 'data' event on the stream
+      // object, as that can ensue in lots of processing when the
+      // client is streaming. https://issues.newrelic.com/browse/NEWRELIC-1460
+    }
+  }
+}
+
+module.exports = function instrument(shim) {
+  const genericShim = shim.makeSpecializedShim(shim.GENERIC, 'call-stream')
+  const callStream = genericShim.require('./build/src/call-stream')
+  genericShim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
+
+  const webFrameworkShim = shim.makeSpecializedShim(shim.WEB_FRAMEWORK, 'server')
+  const grpcVersion = shim.require('./package.json').version
+  if (semver.lt(grpcVersion, '1.4.0')) {
+    shim.logger.debug('gRPC server-side instrumentation only supported on grpc-js >=1.4.0')
+    return
+  }
+
+  const server = webFrameworkShim.require('./build/src/server')
+  webFrameworkShim.setFramework('gRPC')
+  webFrameworkShim.wrap(server.Server.prototype, 'register', wrapRegister)
 }

package/lib/instrumentation/grpc-js/nr-hooks.js

@@ -12,7 +12,7 @@ const grpc = require('./grpc')
  */
 module.exports = [
   {
-    type: 'generic',
+    type: 'conglomerate', // generic shim for client, web framework shim for server
     moduleName: '@grpc/grpc-js',
     onResolved: grpc
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "8.16.0",
+  "version": "8.17.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [