newrelic 8.16.0 → 9.0.0

package/THIRD_PARTY_NOTICES.md

@@ -504,7 +504,7 @@ This product includes source derived from [@grpc/proto-loader](https://github.co
 
 ### @newrelic/aws-sdk
 
-This product includes source derived from [@newrelic/aws-sdk](https://github.com/newrelic/node-newrelic-aws-sdk) ([v4.1.1](https://github.com/newrelic/node-newrelic-aws-sdk/tree/v4.1.1)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-aws-sdk/blob/v4.1.1/LICENSE):
+This product includes source derived from [@newrelic/aws-sdk](https://github.com/newrelic/node-newrelic-aws-sdk) ([v5.0.0](https://github.com/newrelic/node-newrelic-aws-sdk/tree/v5.0.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-aws-sdk/blob/v5.0.0/LICENSE):
 
 ```
                                  Apache License
@@ -712,7 +712,7 @@ This product includes source derived from [@newrelic/aws-sdk](https://github.com
 
 ### @newrelic/koa
 
-This product includes source derived from [@newrelic/koa](https://github.com/newrelic/node-newrelic-koa) ([v6.1.1](https://github.com/newrelic/node-newrelic-koa/tree/v6.1.1)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-koa/blob/v6.1.1/LICENSE):
+This product includes source derived from [@newrelic/koa](https://github.com/newrelic/node-newrelic-koa) ([v7.0.0](https://github.com/newrelic/node-newrelic-koa/tree/v7.0.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-koa/blob/v7.0.0/LICENSE):
 
 ```
 Apache License
@@ -921,7 +921,7 @@ Apache License
 
 ### @newrelic/superagent
 
-This product includes source derived from [@newrelic/superagent](https://github.com/newrelic/node-newrelic-superagent) ([v5.1.0](https://github.com/newrelic/node-newrelic-superagent/tree/v5.1.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-superagent/blob/v5.1.0/LICENSE):
+This product includes source derived from [@newrelic/superagent](https://github.com/newrelic/node-newrelic-superagent) ([v6.0.0](https://github.com/newrelic/node-newrelic-superagent/tree/v6.0.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-newrelic-superagent/blob/v6.0.0/LICENSE):
 
 ```
                                  Apache License
@@ -1800,7 +1800,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ### @newrelic/test-utilities
 
-This product includes source derived from [@newrelic/test-utilities](https://github.com/newrelic/node-test-utilities) ([v6.5.5](https://github.com/newrelic/node-test-utilities/tree/v6.5.5)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-test-utilities/blob/v6.5.5/LICENSE):
+This product includes source derived from [@newrelic/test-utilities](https://github.com/newrelic/node-test-utilities) ([v7.0.0](https://github.com/newrelic/node-test-utilities/tree/v7.0.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-test-utilities/blob/v7.0.0/LICENSE):
 
 ```
                                  Apache License
@@ -3380,7 +3380,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 ### @newrelic/native-metrics
 
-This product includes source derived from [@newrelic/native-metrics](https://github.com/newrelic/node-native-metrics) ([v8.0.0](https://github.com/newrelic/node-native-metrics/tree/v8.0.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-native-metrics/blob/v8.0.0/LICENSE):
+This product includes source derived from [@newrelic/native-metrics](https://github.com/newrelic/node-native-metrics) ([v9.0.0](https://github.com/newrelic/node-native-metrics/tree/v9.0.0)), distributed under the [Apache-2.0 License](https://github.com/newrelic/node-native-metrics/blob/v9.0.0/LICENSE):
 
 ```
                                  Apache License

package/index.js

@@ -53,8 +53,8 @@ function initialize() {
       throw new Error(message)
     }
 
-    // TODO: Update this check when Node v18 support is added
-    if (psemver.satisfies('>=17.0.0')) {
+    // TODO: Update this check when Node v20 support is added
+    if (psemver.satisfies('>=19.0.0')) {
       logger.warn(
         'New Relic for Node.js %s has not been tested on Node.js %s. Please ' +
           'update the agent or downgrade your version of Node.js',

package/lib/collector/http-agents.js

@@ -8,8 +8,6 @@
 const parse = require('url').parse
 const ProxyAgent = require('https-proxy-agent')
 const logger = require('../logger').child({ component: 'http-agent' })
-const certificates = require('./ssl/certificates.js')
-
 const https = require('https')
 
 // poor person's single-instance-objects.  We
@@ -21,6 +19,8 @@ let agentProxyWithKeepAlive = null
 
 /**
  * Returns an HTTP agent with keep-alive enabled
+ *
+ * @param config
  */
 exports.keepAliveAgent = function keepAliveAgent(config) {
   config = config ? config : {}
@@ -45,6 +45,8 @@ exports.keepAliveAgent = function keepAliveAgent(config) {
  * Include keep-alive configuration, but ultimately its up
  * to the proxy server as to how its connection is made
  * with New Relic's servers.
+ *
+ * @param config
  */
 exports.proxyAgent = function proxyAgent(config) {
   if (null !== agentProxyWithKeepAlive) {
@@ -109,25 +111,6 @@ function proxyOptions(config) {
 
   if (config.certificates && config.certificates.length > 0) {
     opts.certificates = config.certificates
-
-    // merge user certificates with built-in certs
-    if (config.feature_flag.certificate_bundle) {
-      logger.info(
-        'Using a proxy with a special cert. This enables our cert bundle which, combined ' +
-          'with some versions of node, exacerbates a leak in node core TLS.'
-      )
-
-      const certWarningMessage = [
-        'Deprecation Warning: The certificate bundle included by New Relic will be ',
-        'disabled by default and then fully removed in later major versions. We recommend ',
-        'testing with the certificate_bundle feature flag set to `false` to determine if ',
-        'you will need to modify your environment or setup your own appropriate bundle. ',
-        'Example configuration: feature_flag: { certificate_bundle: false }.'
-      ].join('')
-      logger.warnOnce('CERT_WARNING', certWarningMessage)
-
-      opts.certificates = config.certificates.concat(certificates)
-    }
   }
 
   return opts

package/lib/collector/remote-method.js

@@ -14,7 +14,6 @@ const parse = require('./parse-response')
 const stringify = require('json-stringify-safe')
 const Sink = require('../util/stream-sink')
 const agents = require('./http-agents')
-const certificates = require('./ssl/certificates')
 const isValidLength = require('../util/byte-limit').isValidLength
 const { DATA_USAGE } = require('../metrics/names')
 
@@ -306,21 +305,6 @@ RemoteMethod.prototype._request = function _request(options) {
   } else {
     if (this._config.certificates && this._config.certificates.length > 0) {
       requestOptions.ca = this._config.certificates
-
-      if (this._config.feature_flag.certificate_bundle) {
-        logger.debug('Adding custom certificate to the cert bundle.')
-
-        const certWarningMessage = [
-          'Deprecation Warning: The certificate bundle included by New Relic will be ',
-          'disabled by default and then fully removed in later major versions. We recommend ',
-          'testing with the certificate_bundle feature flag set to `false` to determine if ',
-          'you will need to modify your environment or setup your own appropriate bundle. ',
-          'Example configuration: feature_flag: { certificate_bundle: false }.'
-        ].join('')
-        logger.warnOnce('CERT_WARNING', certWarningMessage)
-
-        requestOptions.ca = this._config.certificates.concat(certificates)
-      }
     }
     request = https.request(requestOptions)
   }

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/config/index.js

@@ -858,13 +858,6 @@ Config.prototype.logUnknown = function logUnknown(json, key) {
   logger.debug('New Relic sent unknown configuration parameter %s with value %s.', key, value)
 }
 
-/**
- * Return the availability of async_hook for use by the agent.
- */
-Config.prototype.checkAsyncHookStatus = function checkAsyncHookStatus() {
-  return this.feature_flag.await_support
-}
-
 /**
  * Gets the user set host display name. If not provided, it returns the default value.
  *

package/lib/feature_flags.js

@@ -7,8 +7,6 @@
 
 // unreleased flags gating an active feature
 exports.prerelease = {
-  await_support: true,
-  certificate_bundle: false,
   express5: false,
   new_promise_tracking: false,
   promise_segments: false,
@@ -31,7 +29,9 @@ exports.released = [
   'send_request_uri_attribute',
   'synthetics',
   'dt_format_w3c',
-  'fastify_instrumentation'
+  'fastify_instrumentation',
+  'await_support',
+  'certificate_bundle'
 ]
 
 // flags that are no longer used for unreleased features

package/lib/instrumentation/core/async_hooks.js

@@ -6,48 +6,11 @@
 'use strict'
 
 const logger = require('../../logger').child({ component: 'async_hooks' })
-const promInit = require('../promise')
+const asyncHooks = require('async_hooks')
 
 module.exports = initialize
 
-/**
- * The spec for the native `Promise` class.
- */
-const STATIC_PROMISE_METHODS = ['accept', 'all', 'defer', 'race', 'reject', 'resolve']
-const NATIVE_PROMISE_SPEC = {
-  name: 'global',
-  constructor: 'Promise',
-  executor: true,
-  useFinally: false,
-  $proto: {
-    then: ['then', 'chain'],
-    catch: ['catch']
-  },
-  $static: {
-    $copy: STATIC_PROMISE_METHODS,
-    cast: STATIC_PROMISE_METHODS
-  }
-}
-
 function initialize(agent, shim) {
-  const enableHooks = agent.config.checkAsyncHookStatus()
-  if (enableHooks && tryAsyncHooks(agent, shim)) {
-    logger.debug('Using async_hooks.')
-  } else {
-    logger.debug('Using promise instrumentation.')
-    promInit(agent, global, NATIVE_PROMISE_SPEC)
-  }
-}
-
-function tryAsyncHooks(agent, shim) {
-  let asyncHooks = null
-  try {
-    asyncHooks = require('async_hooks')
-  } catch (e) {
-    logger.info(e, 'Not using async_hooks module.')
-    return false
-  }
-
   // this map is reused to track the segment that was active when
   // the before callback is called to be replaced in the after callback
   const segmentMap = new Map()

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

@@ -17,7 +17,7 @@ const NAMES = require('../../metrics/names')
 const SHIM_SYMBOLS = require('../../shim/constants').SYMBOLS
 
 const DEFAULT_HOST = 'localhost'
-const DEFAULT_PORT = 80
+const DEFAULT_HTTP_PORT = 80
 const DEFAULT_SSL_PORT = 443
 
 const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
@@ -27,9 +27,8 @@ const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
  *
  * @param {Agent} agent
  * @param {object} opts
- * @param {function} makeRequest
- *
- * @return {http.ClientRequest} The instrumented outbound request.
+ * @param {Function} makeRequest
+ * @returns {http.ClientRequest} The instrumented outbound request.
  */
 module.exports = function instrumentOutbound(agent, opts, makeRequest) {
   if (typeof opts === 'string') {
@@ -38,10 +37,12 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
     opts = copy.shallow(opts)
   }
 
+  const defaultPort =
+    !opts.protocol || opts.protocol === 'http:' ? DEFAULT_HTTP_PORT : DEFAULT_SSL_PORT
   let hostname = opts.hostname || opts.host || DEFAULT_HOST
   let port = opts.port || opts.defaultPort
   if (!port) {
-    port = !opts.protocol || opts.protocol === 'http:' ? DEFAULT_PORT : DEFAULT_SSL_PORT
+    port = defaultPort
   }
 
   if (!hostname || port < 1) {
@@ -49,11 +50,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
     return makeRequest(opts)
   }
 
-  // Technically we shouldn't append the port if this is an https request on 443
-  // but due to legacy issues we can't do that without moving customer's cheese.
-  //
-  // TODO: Move customers cheese by not appending the default port for https.
-  if (port && port !== DEFAULT_PORT) {
+  if (port && port !== defaultPort) {
     hostname += ':' + port
   }
 
@@ -159,8 +156,7 @@ module.exports = function instrumentOutbound(agent, opts, makeRequest) {
  * @param {TraceSegment} segment
  * @param {http.ClientRequest} req
  * @param {Error} error
- *
- * @return {bool} True if the error will be collected by New Relic.
+ * @returns {bool} True if the error will be collected by New Relic.
  */
 function handleError(segment, req, error) {
   if (req.listenerCount('error') > 0) {

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

@@ -6,80 +6,217 @@
 '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 segment = shim.createSegment({
+      name: `External/${authorityName}${this.methodName}`,
+      opaque: true,
+      recorder: recordExternal(authorityName, 'gRPC')
+    })
+
+    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.')
       }
 
-      const channel = this.channel
-      const authorityName = (channel.target && channel.target.path) || channel.getDefaultAuthority
+      args[0] = nrMetadata
 
-      const segment = shim.createSegment({
-        name: `External/${authorityName}${this.methodName}`,
-        opaque: true,
-        recorder: recordExternal(authorityName, 'gRPC')
-      })
+      const originalListener = args[1]
+      const nrListener = Object.assign({}, originalListener)
+      nrListener.onReceiveStatus = (status) => {
+        const { code, details } = status
+
+        segment.addAttribute('grpc.statusCode', code)
+        segment.addAttribute('grpc.statusText', details)
+
+        // 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)
+        }
 
-      return shim.applySegment(callStart, segment, true, this, arguments)
+        segment.addAttribute('component', 'gRPC')
 
-      function callStart() {
-        const args = shim.argsToArray.apply(shim, arguments)
+        const protocol = 'grpc'
 
-        const transaction = segment.transaction
+        const url = `${protocol}://${authorityName}${this.methodName}`
 
-        const originalMetadata = args[0]
-        const nrMetadata = originalMetadata.clone()
+        segment.addAttribute('http.url', url)
+        segment.addAttribute('http.method', this.methodName)
 
-        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.')
+        if (originalListener && originalListener.onReceiveStatus) {
+          const onReceiveStatuts = shim.bindSegment(originalListener.onReceiveStatus, segment)
+          onReceiveStatuts(status)
         }
+        segment.end()
+      }
 
-        args[0] = nrMetadata
+      args[1] = nrListener
 
-        const originalListener = args[1]
-        const nrListener = Object.assign({}, originalListener)
-        nrListener.onReceiveStatus = (status) => {
-          const { code, details } = status
+      return original.apply(this, args)
+    }
+  }
+}
 
-          segment.addAttribute('grpc.statusCode', code)
-          segment.addAttribute('grpc.statusText', details)
+/**
+ * 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')
 
-          // 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)
-          }
+  return function wrappedRegister() {
+    const args = shim.argsToArray.apply(shim, arguments)
 
-          segment.addAttribute('component', 'gRPC')
+    const name = args[0]
+    const handler = args[1]
+    const type = args[args.length - 1]
 
-          const protocol = 'grpc'
+    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)
+    }
 
-          const url = `${protocol}://${authorityName}${this.methodName}`
+    args[1] = shim.bindCreateTransaction(instrumentedHandler, { type: shim.WEB })
 
-          segment.addAttribute('http.url', url)
-          segment.addAttribute('http.method', this.methodName)
+    return original.apply(this, args)
 
-          segment.end()
+    function instrumentedHandler(stream) {
+      const { transaction, segment } = createTransaction()
+      acceptDTHeaders(stream, transaction)
+      instrumentEventListeners(stream, transaction)
+      return shim.applySegment(handler, segment, true, this, arguments)
+    }
 
-          originalListener && originalListener.onReceiveStatus(status)
-        }
+    function createTransaction() {
+      const parent = shim.getActiveSegment()
+      const transaction = parent.transaction
 
-        args[1] = nrListener
+      // 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()
 
-        return original.apply(this, args)
-      }
+      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/lib/instrumentation/hapi.js

@@ -27,16 +27,7 @@ module.exports = function initialize(agent, hapi, moduleName, shim) {
   } else if (hapi.Server) {
     // Server.connection was removed in v17
     if (!hapi.Server.prototype.connection) {
-      return require('./hapi/hapi-17')(agent, hapi, moduleName, shim)
-    }
-
-    // See if we can find the plugin class. This should be the super class of
-    // Server and will cover more scenarios.
-    const Plugin = hapi.Server.super_
-    if (_isPluginClass(Plugin)) {
-      wrapServer(shim, Plugin)
-    } else {
-      wrapServer(shim, hapi.Server)
+      return require('./hapi/hapi')(agent, hapi, moduleName, shim)
     }
   }
 }
@@ -251,19 +242,6 @@ function wrapMiddleware(shim, middleware, event) {
   return shim.recordMiddleware(middleware, spec)
 }
 
-function _isPluginClass(Plugin) {
-  if (typeof Plugin !== 'function' || !Plugin.prototype) {
-    return false
-  }
-
-  const proto = Plugin.prototype
-  return (
-    typeof proto.handler === 'function' &&
-    typeof proto.route === 'function' &&
-    typeof proto.ext === 'function'
-  )
-}
-
 function wrapReply(wrap, reply, isPreHandler) {
   const isFinal = !isPreHandler
   // The only reply method that is actually used by pre-handlers is `response`. All