newrelic 9.4.0 → 9.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "9.4.0",
+  "version": "9.6.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -146,8 +146,8 @@
     "bench": "node ./bin/run-bench.js",
     "docker-env": "./bin/docker-env-vars.sh",
     "docs": "npm ci && jsdoc -c ./jsdoc-conf.json --private -r .",
-    "integration": "npm run prepare-test && npm run sub-install && time tap --test-regex='(\\/|^test\\/integration\\/.*\\.tap\\.js)$' --timeout=180 --no-coverage --reporter classic",
-    "integration:async-local": "npm run prepare-test && npm run sub-install && time tap --test-regex='(\\/|^test\\/integration\\/.*\\.tap\\.js)$' --timeout=180 --no-coverage --reporter classic --test-env=NEW_RELIC_FEATURE_FLAG_ASYNC_LOCAL_CONTEXT=1",
+    "integration": "npm run prepare-test && npm run sub-install && time c8 -o ./coverage/integration tap --test-regex='(\\/|^test\\/integration\\/.*\\.tap\\.js)$' --timeout=180 --no-coverage --reporter classic",
+    "integration:async-local": "npm run prepare-test && npm run sub-install && time c8 -o ./coverage/integration-async-local tap --test-regex='(\\/|^test\\/integration\\/.*\\.tap\\.js)$' --timeout=360 --no-coverage --reporter classic --test-env=NEW_RELIC_FEATURE_FLAG_ASYNC_LOCAL_CONTEXT=1",
     "prepare-test": "npm run ssl && npm run docker-env",
     "lint": "eslint ./*.{js,mjs} lib test bin examples",
     "lint:fix": "eslint --fix, ./*.{js,mjs} lib test bin examples",

package/lib/config/env.js

@@ -1,294 +0,0 @@
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-// Map of configuration values to their associated environment value names.
-const ENV_MAPPING = {
-  newrelic_home: 'NEW_RELIC_HOME',
-  app_name: 'NEW_RELIC_APP_NAME',
-  license_key: 'NEW_RELIC_LICENSE_KEY',
-  apdex_t: 'NEW_RELIC_APDEX_T',
-  security_policies_token: 'NEW_RELIC_SECURITY_POLICIES_TOKEN',
-  ssl: 'NEW_RELIC_USE_SSL',
-  host: 'NEW_RELIC_HOST',
-  port: 'NEW_RELIC_PORT',
-  proxy: 'NEW_RELIC_PROXY_URL',
-  proxy_host: 'NEW_RELIC_PROXY_HOST',
-  proxy_port: 'NEW_RELIC_PROXY_PORT',
-  proxy_user: 'NEW_RELIC_PROXY_USER',
-  proxy_pass: 'NEW_RELIC_PROXY_PASS',
-  agent_enabled: 'NEW_RELIC_ENABLED',
-  allow_all_headers: 'NEW_RELIC_ALLOW_ALL_HEADERS',
-  compressed_content_encoding: 'NEW_RELIC_COMPRESSED_CONTENT_ENCODING',
-  attributes: {
-    enabled: 'NEW_RELIC_ATTRIBUTES_ENABLED',
-    exclude: 'NEW_RELIC_ATTRIBUTES_EXCLUDE',
-    include: 'NEW_RELIC_ATTRIBUTES_INCLUDE',
-    include_enabled: 'NEW_RELIC_ATTRIBUTES_INCLUDE_ENABLED'
-  },
-  logging: {
-    level: 'NEW_RELIC_LOG_LEVEL',
-    filepath: 'NEW_RELIC_LOG',
-    enabled: 'NEW_RELIC_LOG_ENABLED'
-  },
-  audit_log: {
-    enabled: 'NEW_RELIC_AUDIT_LOG_ENABLED',
-    endpoints: 'NEW_RELIC_AUDIT_LOG_ENDPOINTS'
-  },
-  error_collector: {
-    attributes: {
-      enabled: 'NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_ENABLED'
-    },
-    enabled: 'NEW_RELIC_ERROR_COLLECTOR_ENABLED',
-    ignore_status_codes: 'NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERROR_CODES',
-    ignore_classes: 'NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERRORS',
-    expected_status_codes: 'NEW_RELIC_ERROR_COLLECTOR_EXPECTED_ERROR_CODES',
-    expected_classes: 'NEW_RELIC_ERROR_COLLECTOR_EXPECTED_ERRORS',
-    max_event_samples_stored: 'NEW_RELIC_ERROR_COLLECTOR_MAX_EVENT_SAMPLES_STORED'
-  },
-  strip_exception_messages: {
-    enabled: 'NEW_RELIC_STRIP_EXCEPTION_MESSAGES_ENABLED'
-  },
-  transaction_events: {
-    attributes: {
-      enabled: 'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_ENABLED',
-      exclude: 'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_EXCLUDE',
-      include: 'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_INCLUDE'
-    },
-    max_samples_stored: 'NEW_RELIC_TRANSACTION_EVENTS_MAX_SAMPLES_STORED'
-  },
-  custom_insights_events: {
-    max_samples_stored: 'NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED'
-  },
-  transaction_tracer: {
-    attributes: {
-      enabled: 'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_ENABLED',
-      exclude: 'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_EXCLUDE',
-      include: 'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_INCLUDE'
-    },
-    enabled: 'NEW_RELIC_TRACER_ENABLED',
-    transaction_threshold: 'NEW_RELIC_TRACER_THRESHOLD',
-    top_n: 'NEW_RELIC_TRACER_TOP_N',
-    record_sql: 'NEW_RELIC_RECORD_SQL',
-    explain_threshold: 'NEW_RELIC_EXPLAIN_THRESHOLD',
-    hide_internals: 'NEW_RELIC_HIDE_INTERNALS'
-  },
-  utilization: {
-    detect_aws: 'NEW_RELIC_UTILIZATION_DETECT_AWS',
-    detect_pcf: 'NEW_RELIC_UTILIZATION_DETECT_PCF',
-    detect_azure: 'NEW_RELIC_UTILIZATION_DETECT_AZURE',
-    detect_gcp: 'NEW_RELIC_UTILIZATION_DETECT_GCP',
-    detect_docker: 'NEW_RELIC_UTILIZATION_DETECT_DOCKER',
-    detect_kubernetes: 'NEW_RELIC_UTILIZATION_DETECT_KUBERNETES',
-    logical_processors: 'NEW_RELIC_UTILIZATION_LOGICAL_PROCESSORS',
-    total_ram_mib: 'NEW_RELIC_UTILIZATION_TOTAL_RAM_MIB',
-    billing_hostname: 'NEW_RELIC_UTILIZATION_BILLING_HOSTNAME'
-  },
-  rules: {
-    name: 'NEW_RELIC_NAMING_RULES',
-    ignore: 'NEW_RELIC_IGNORING_RULES'
-  },
-  enforce_backstop: 'NEW_RELIC_ENFORCE_BACKSTOP',
-  browser_monitoring: {
-    attributes: {
-      enabled: 'NEW_RELIC_BROWSER_MONITORING_ATTRIBUTES_ENABLED',
-      exclude: 'NEW_RELIC_BROWSER_MONITORING_ATTRIBUTES_EXCLUDE',
-      include: 'NEW_RELIC_BROWSER_MONITORING_ATTRIBUTES_INCLUDE'
-    },
-    enable: 'NEW_RELIC_BROWSER_MONITOR_ENABLE',
-    debug: 'NEW_RELIC_BROWSER_MONITOR_DEBUG'
-  },
-  high_security: 'NEW_RELIC_HIGH_SECURITY',
-  labels: 'NEW_RELIC_LABELS',
-  slow_sql: {
-    enabled: 'NEW_RELIC_SLOW_SQL_ENABLED',
-    max_samples: 'NEW_RELIC_MAX_SQL_SAMPLES'
-  },
-  process_host: {
-    display_name: 'NEW_RELIC_PROCESS_HOST_DISPLAY_NAME',
-    ipv_preference: 'NEW_RELIC_IPV_PREFERENCE'
-  },
-  api: {
-    custom_attributes_enabled: 'NEW_RELIC_API_CUSTOM_ATTRIBUTES',
-    custom_events_enabled: 'NEW_RELIC_API_CUSTOM_EVENTS',
-    notice_error_enabled: 'NEW_RELIC_API_NOTICE_ERROR',
-    esm: {
-      custom_instrumentation_entrypoint: 'NEW_RELIC_API_ESM_CUSTOM_INSTRUMENTATION_ENTRYPOINT'
-    }
-  },
-  datastore_tracer: {
-    instance_reporting: {
-      enabled: 'NEW_RELIC_DATASTORE_INSTANCE_REPORTING_ENABLED'
-    },
-    database_name_reporting: {
-      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: {
-      enabled: 'NEW_RELIC_SPAN_EVENTS_ATTRIBUTES_ENABLED',
-      exclude: 'NEW_RELIC_SPAN_EVENTS_ATTRIBUTES_EXCLUDE',
-      include: 'NEW_RELIC_SPAN_EVENTS_ATTRIBUTES_INCLUDE'
-    },
-    max_samples_stored: 'NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED'
-  },
-  transaction_segments: {
-    attributes: {
-      enabled: 'NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_ENABLED',
-      exclude: 'NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_EXCLUDE',
-      include: 'NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_INCLUDE'
-    }
-  },
-  distributed_tracing: {
-    enabled: 'NEW_RELIC_DISTRIBUTED_TRACING_ENABLED',
-    exclude_newrelic_header: 'NEW_RELIC_DISTRIBUTED_TRACING_EXCLUDE_NEWRELIC_HEADER'
-  },
-  message_tracer: {
-    segment_parameters: {
-      enabled: 'NEW_RELIC_MESSAGE_TRACER_SEGMENT_PARAMETERS_ENABLED'
-    }
-  },
-  serverless_mode: {
-    enabled: 'NEW_RELIC_SERVERLESS_MODE_ENABLED'
-  },
-  plugins: {
-    native_metrics: {
-      enabled: 'NEW_RELIC_NATIVE_METRICS_ENABLED'
-    }
-  },
-  trusted_account_key: 'NEW_RELIC_TRUSTED_ACCOUNT_KEY',
-  primary_application_id: 'NEW_RELIC_PRIMARY_APPLICATION_ID',
-  account_id: 'NEW_RELIC_ACCOUNT_ID',
-  infinite_tracing: {
-    trace_observer: {
-      host: 'NEW_RELIC_INFINITE_TRACING_TRACE_OBSERVER_HOST',
-      port: 'NEW_RELIC_INFINITE_TRACING_TRACE_OBSERVER_PORT'
-    },
-    span_events: {
-      queue_size: 'NEW_RELIC_INFINITE_TRACING_SPAN_EVENTS_QUEUE_SIZE'
-    }
-  },
-  application_logging: {
-    enabled: 'NEW_RELIC_APPLICATION_LOGGING_ENABLED',
-    forwarding: {
-      enabled: 'NEW_RELIC_APPLICATION_LOGGING_FORWARDING_ENABLED',
-      max_samples_stored: 'NEW_RELIC_APPLICATION_LOGGING_FORWARDING_MAX_SAMPLES_STORED'
-    },
-    metrics: {
-      enabled: 'NEW_RELIC_APPLICATION_LOGGING_METRICS_ENABLED'
-    },
-    local_decorating: {
-      enabled: 'NEW_RELIC_APPLICATION_LOGGING_LOCAL_DECORATING_ENABLED'
-    }
-  },
-  ignore_server_configuration: 'NEW_RELIC_IGNORE_SERVER_SIDE_CONFIG'
-}
-
-// List of environment values which are comma-delimited lists.
-const LIST_VARS = new Set([
-  'NEW_RELIC_APP_NAME',
-  'NEW_RELIC_ATTRIBUTES_EXCLUDE',
-  'NEW_RELIC_ATTRIBUTES_INCLUDE',
-  'NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERROR_CODES',
-  'NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERRORS',
-  'NEW_RELIC_ERROR_COLLECTOR_EXPECTED_ERROR_CODES',
-  'NEW_RELIC_ERROR_COLLECTOR_EXPECTED_ERRORS',
-  'NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_EXCLUDE',
-  'NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_INCLUDE',
-  'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_EXCLUDE',
-  'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_INCLUDE',
-  'NEW_RELIC_BROWSER_MONITORING_ATTRIBUTES_EXCLUDE',
-  'NEW_RELIC_BROWSER_MONITORING_ATTRIBUTES_INCLUDE',
-  'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_EXCLUDE',
-  'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_INCLUDE',
-  'NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_EXCLUDE',
-  'NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_INCLUDE',
-  'NEW_RELIC_SPAN_EVENTS_ATTRIBUTES_EXCLUDE',
-  'NEW_RELIC_SPAN_EVENTS_ATTRIBUTES_INCLUDE',
-  'NEW_RELIC_IGNORING_RULES',
-  'NEW_RELIC_AUDIT_LOG_ENDPOINTS'
-])
-
-// Mapping to customize the split delimiter for the LIST_VARS
-const LIST_VARS_CUSTOM_DELIMITERS = {
-  NEW_RELIC_APP_NAME: /;|,/
-}
-
-// Values in object lists are comma-delimited object literals
-const OBJECT_LIST_VARS = new Set(['NEW_RELIC_NAMING_RULES'])
-
-// Values in boolean variables. Is pretty tolerant about values, but don't get
-// fancy--just use 'true' and 'false', everybody.
-const BOOLEAN_VARS = new Set([
-  'NEW_RELIC_ENABLED',
-  'NEW_RELIC_ALLOW_ALL_HEADERS',
-  'NEW_RELIC_ATTRIBUTES_ENABLED',
-  'NEW_RELIC_ERROR_COLLECTOR_ENABLED',
-  'NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_ENABLED',
-  'NEW_RELIC_STRIP_EXCEPTION_MESSAGES_ENABLED',
-  'NEW_RELIC_ATTRIBUTES_INCLUDE_ENABLED',
-  'NEW_RELIC_TRACER_ENABLED',
-  'NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_ENABLED',
-  'NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_ENABLED',
-  'NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_ENABLED',
-  'NEW_RELIC_DEBUG_METRICS',
-  'NEW_RELIC_DEBUG_TRACER',
-  'NEW_RELIC_ENFORCE_BACKSTOP',
-  'NEW_RELIC_USE_SSL',
-  'NEW_RELIC_BROWSER_MONITOR_ENABLE',
-  'NEW_RELIC_BROWSER_MONITORING_ATTRIBUTES_ENABLED',
-  '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',
-  'NEW_RELIC_DISTRIBUTED_TRACING_EXCLUDE_NEWRELIC_HEADER',
-  'NEW_RELIC_LOG_ENABLED',
-  'NEW_RELIC_AUDIT_LOG_ENABLED',
-  'NEW_RELIC_DATASTORE_DATABASE_NAME_REPORTING_ENABLED',
-  'NEW_RELIC_DATASTORE_INSTANCE_REPORTING_ENABLED',
-  'NEW_RELIC_MESSAGE_TRACER_SEGMENT_PARAMETERS_ENABLED',
-  'NEW_RELIC_UTILIZATION_DETECT_AWS',
-  'NEW_RELIC_UTILIZATION_DETECT_PCF',
-  'NEW_RELIC_UTILIZATION_DETECT_AZURE',
-  'NEW_RELIC_UTILIZATION_DETECT_DOCKER',
-  'NEW_RELIC_UTILIZATION_DETECT_GCP',
-  'NEW_RELIC_UTILIZATION_DETECT_KUBERNETES',
-  'NEW_RELIC_SERVERLESS_MODE_ENABLED',
-  'NEW_RELIC_NATIVE_METRICS_ENABLED',
-  'NEW_RELIC_APPLICATION_LOGGING_ENABLED',
-  'NEW_RELIC_APPLICATION_LOGGING_FORWARDING_ENABLED',
-  'NEW_RELIC_APPLICATION_LOGGING_METRICS_ENABLED',
-  'NEW_RELIC_APPLICATION_LOGGING_LOCAL_DECORATING_ENABLED',
-  'NEW_RELIC_IGNORE_SERVER_SIDE_CONFIG'
-])
-
-const FLOAT_VARS = new Set(['NEW_RELIC_APDEX_T', 'NEW_RELIC_TRACER_THRESHOLD'])
-
-const INT_VARS = new Set([
-  'NEW_RELIC_EXPLAIN_THRESHOLD',
-  'NEW_RELIC_MAX_SQL_SAMPLES',
-  'NEW_RELIC_INFINITE_TRACING_SPAN_EVENTS_QUEUE_SIZE',
-  'NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED',
-  'NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED',
-  'NEW_RELIC_TRANSACTION_EVENTS_MAX_SAMPLES_STORED',
-  'NEW_RELIC_ERROR_COLLECTOR_MAX_EVENT_SAMPLES_STORED',
-  'NEW_RELIC_APPLICATION_LOGGING_FORWARDING_MAX_SAMPLES_STORED'
-])
-
-exports.ENV_MAPPING = ENV_MAPPING
-exports.LIST_VARS = LIST_VARS
-exports.LIST_VARS_CUSTOM_DELIMITERS = LIST_VARS_CUSTOM_DELIMITERS
-exports.OBJECT_LIST_VARS = OBJECT_LIST_VARS
-exports.BOOLEAN_VARS = BOOLEAN_VARS
-exports.FLOAT_VARS = FLOAT_VARS
-exports.INT_VARS = INT_VARS

package/lib/instrumentation/hapi/hapi.js

@@ -1,207 +0,0 @@
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-const shared = require('./shared')
-const record = require('../../metrics/recorders/generic')
-
-// TODO: abstract and consolidate mostly-shared hapi functionality
-module.exports = function initialize(agent, hapi, moduleName, shim) {
-  // At this point, framework and error predicate have both already been set via ./hapi,
-  // so we only need to set the response predicate and wrap the server object
-  shim.setResponsePredicate(function hapiResponsePredicate(args, result) {
-    return !(result instanceof Error) && result !== args[1].continue
-  })
-
-  // 'Server' and 'server' both point to the same export,
-  // but we can't make any assumption about which will be used.
-  // Since we wrap the prototype, the second wrap should exit early.
-  shim.wrapReturn(hapi, 'server', serverFactoryWrapper)
-  shim.wrapReturn(hapi, 'Server', serverFactoryWrapper)
-}
-
-function serverFactoryWrapper(shim, fn, fnName, server) {
-  serverPostConstructor.call(server, shim)
-}
-
-function serverPostConstructor(shim) {
-  const proto = Object.getPrototypeOf(this)
-
-  if (shim.isWrapped(proto.decorate)) {
-    shim.logger.trace('Already wrapped Server proto, not wrapping again')
-    return
-  }
-
-  shim.wrap(proto, 'decorate', function wrapDecorate(shim, original) {
-    return function wrappedDecorate(type) {
-      // server.decorate also accepts 'request', 'toolkit', 'server' types,
-      // but we're only concerned with 'handler'
-      if (type !== 'handler') {
-        return original.apply(this, arguments)
-      }
-
-      // Convert arguments to usable array
-      const args = shim.argsToArray.apply(shim, arguments)
-
-      // Wrap the third server.decorate arg, the user-defined handler
-      shim.wrap(args, shim.THIRD, function wrapHandler(shim, fn) {
-        if (typeof fn !== 'function') {
-          return
-        }
-
-        if (fn.defaults) {
-          wrappedHandler.defaults = fn.defaults
-        }
-
-        return wrappedHandler
-
-        function wrappedHandler(route) {
-          const ret = fn.apply(this, arguments)
-
-          return typeof ret === 'function' ? wrapRouteHandler(shim, ret, route && route.path) : ret
-        }
-      })
-
-      return original.apply(this, args)
-    }
-  })
-
-  shim.wrap(proto, 'route', function wrapRoute(shim, original) {
-    return function wrappedRoute() {
-      const args = shim.argsToArray.apply(shim, arguments)
-
-      if (!shim.isObject(args[0])) {
-        return original.apply(this, args)
-      }
-
-      // If route is created via a plugin, pull prefix if it exists
-      const prefix =
-        (this.realm &&
-          this.realm.modifiers &&
-          this.realm.modifiers.route &&
-          this.realm.modifiers.route.prefix) ||
-        ''
-
-      _wrapRoute(shim, args[0])
-
-      return original.apply(this, args)
-
-      function _wrapRoute(shim, route) {
-        const routePath = prefix + route.path
-        if (shim.isArray(route)) {
-          for (let i = 0; i < route.length; ++i) {
-            _wrapRoute(shim, route[i])
-          }
-          return
-        } else if (route.options) {
-          // v17 now prefers `options` property...
-          if (route.options.pre) {
-            // config objects can also contain multiple OTHER handlers in a `pre` array
-            route.options.pre = wrapPreHandlers(shim, route.options.pre, routePath)
-          }
-          if (route.options.handler) {
-            _wrapRouteHandler(shim, route.options, routePath)
-            return
-          }
-        } else if (route.config) {
-          // ... but `config` still works
-          if (route.config.pre) {
-            route.config.pre = wrapPreHandlers(shim, route.config.pre, routePath)
-          }
-          if (route.config.handler) {
-            _wrapRouteHandler(shim, route.config, routePath)
-            return
-          }
-        }
-        _wrapRouteHandler(shim, route, routePath)
-      }
-
-      function _wrapRouteHandler(shim, container, path) {
-        if (typeof container.handler !== 'function') {
-          return
-        }
-        shim.wrap(container, 'handler', function wrapHandler(shim, handler) {
-          return wrapRouteHandler(shim, handler, path)
-        })
-      }
-    }
-  })
-
-  shim.wrap(proto, 'ext', function wrapExt(shim, original) {
-    return function wrappedExt(event, method) {
-      const args = shim.argsToArray.apply(shim, arguments)
-
-      if (shim.isArray(event)) {
-        for (let i = 0; i < event.length; i++) {
-          event[i].method = wrapMiddleware(shim, event[i].method, event[i].type)
-        }
-      } else if (shim.isObject(event)) {
-        event.method = wrapMiddleware(shim, event.method, event.type)
-      } else if (shim.isString(event)) {
-        args[1] = wrapMiddleware(shim, method, event)
-      } else {
-        shim.logger.debug('Unsupported event type %j', event)
-        return
-      }
-
-      return original.apply(this, args)
-    }
-  })
-}
-
-function wrapPreHandlers(shim, container, path) {
-  if (shim.isArray(container)) {
-    for (let i = 0; i < container.length; ++i) {
-      container[i] = wrapPreHandlers(shim, container[i], path)
-    }
-    return container
-  } else if (shim.isFunction(container)) {
-    return wrapPreHandler(shim, container, path)
-  } else if (container.method && shim.isFunction(container.method)) {
-    return shim.wrap(container, 'method', function wrapHandler(shim, handler) {
-      return wrapPreHandler(shim, handler, path)
-    })
-  }
-}
-
-function wrapPreHandler(shim, container, path) {
-  return shim.record(container, (shim) => {
-    return { name: [shim.HAPI, ' pre handler: ', '(', path, ')'].join(''), recorder: record }
-  })
-}
-
-function wrapRouteHandler(shim, handler, path) {
-  return shim.recordMiddleware(handler, {
-    route: path,
-    req: function getReq(shim, fn, fnName, args) {
-      const request = args[0]
-      if (request && request.raw) {
-        return request.raw.req
-      }
-    },
-    promise: true,
-    params: function getParams(shim, fn, fnName, args) {
-      const req = args[0]
-      return req && req.params
-    }
-  })
-}
-
-function wrapMiddleware(shim, middleware, event) {
-  if (!shared.ROUTE_EVENTS[event]) {
-    return middleware
-  }
-
-  return shim.recordMiddleware(middleware, {
-    route: event,
-    type: event === 'onPreResponse' ? shim.ERRORWARE : shim.MIDDLEWARE,
-    promise: true,
-    req: function getReq(shim, fn, fnName, args) {
-      const req = args[0]
-      return req && req.raw && req.raw.req
-    }
-  })
-}

package/lib/instrumentation/hapi/shared.js

@@ -1,28 +0,0 @@
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-'use strict'
-
-// This object defines all the events that we want to wrap extensions
-// for, as they are the only ones associated with requests.
-const ROUTE_EVENTS = {
-  onRequest: true,
-  onPreAuth: true,
-  onCredentials: true,
-  onPostAuth: true,
-  onPreHandler: true,
-  onPostHandler: true,
-  onPreResponse: true,
-
-  // Server events
-  onPreStart: false,
-  onPostStart: false,
-  onPreStop: false,
-  onPostStop: false
-}
-
-module.exports = {
-  ROUTE_EVENTS: ROUTE_EVENTS
-}