function _postLoad(agent, nodule, name, resolvedName, esmResolver) {
  const simpleName = shimmer.getInstrumentationNameFromModuleName(name)
  const registeredInstrumentations = shimmer.registeredInstrumentations.getAllByName(simpleName)
  const hasPostLoadInstrumentation =
    registeredInstrumentations &&
    registeredInstrumentations.length &&
    registeredInstrumentations.filter((ri) => ri.instrumentation.onRequire).length

  // Check if this is a known instrumentation and then run it.
  if (hasPostLoadInstrumentation) {
    if (resolvedName === undefined && isAbsolutePath(name) === true) {
      // `resolvedName` comes from the `basedir` returned by the `Hook`
      // function from import-in-the-middle or require-in-the-middle. At least
      // with IITM, if the path string does not include a `node_modules` then
      // `basedir` will be `undefined`. But we need it for our instrumentation
      // to work. We'll only reach this situation if the module being
      // instrumented has an `absolutePath` defined. So we detect that and
      // assign appropriately.
      resolvedName = name
    }
    shimmer.registeredInstrumentations.setResolvedName(simpleName, resolvedName)
    logger.trace('Instrumenting %s with onRequire (module loaded) hook.', name)
    return instrumentPostLoad(agent, nodule, simpleName, resolvedName, esmResolver)
  }

  return nodule
}
Invoked directly after a module is loaded via `require` (or `import`). This
is the first opportunity for us to work with the newly loaded module. Prior
to this, the only information we have is the simple name (the string used
to load the module), as well as the `onRequire` and `onError` hooks to
attach to the module.

@param {object} agent
@param {object} nodule The newly loaded module.
@param {string} name The simple name used to load the module.
@param {string} resolvedName The full file system path to the module.
@param {object} [esmResolver]
@returns {*|Object|undefined}
@private