@aidra/pmx-io 0.0.0-stage → 9.14.0

package/lib/hooks.js

@@ -0,0 +1,151 @@
+// Copyright (c) 2026 Mike Warriner. All rights reserved. Proprietary — see LICENSE.
+'use strict'
+
+// Process-wide prototype hooks for HTTP/HTTPS servers and TCP sockets.
+// Installed once per process (shared through a global registry, so several copies of
+// the library never wrap twice) and gated by handlers that the active instance sets.
+
+const context = require('./tracing/context')
+
+const REGISTRY = Symbol.for('@pmx/io:hooks')
+
+function registry () {
+  let r = globalThis[REGISTRY]
+  if (!r) {
+    r = { installed: {}, handlers: { request: null, socketWrite: null, socketRead: null } }
+    Object.defineProperty(globalThis, REGISTRY, { value: r, enumerable: false, configurable: true })
+  }
+  return r
+}
+
+function wrapServerEmit (proto, protocol) {
+  const orig = proto.emit
+  proto.emit = function emit (event, req, res) {
+    if (event === 'request') {
+      const h = registry().handlers.request
+      if (h) {
+        let store
+        try {
+          store = h(protocol, req, res)
+        } catch (_) {}
+        // the request listeners run inside the SERVER span's context (80 NIO-220)
+        if (store !== undefined) return context.run(store, orig, this, arguments)
+      }
+    }
+    return orig.apply(this, arguments)
+  }
+}
+
+function nodeMajor () {
+  return Number(String(process.versions.node || '0').split('.')[0])
+}
+
+/**
+ * Measure every http and https server. On Node >= 20 the built-in diagnostics channel
+ * `http.server.request.start` is used (it covers https too, and needs neither module to be
+ * loaded eagerly — loading them costs ~18 ms, NIO-024). Elsewhere (Bun, older Node) the
+ * servers' `emit` is wrapped.
+ */
+function installHttpServers () {
+  const r = registry()
+  if (r.installed.http) return
+  r.installed.http = true
+  if (!process.versions.bun && nodeMajor() >= 20) {
+    try {
+      const dc = require('diagnostics_channel')
+      dc.subscribe('http.server.request.start', (msg) => {
+        const h = registry().handlers.request
+        if (!h || !msg) return
+        const req = msg.request
+        const protocol = req && req.socket && req.socket.encrypted ? 'https' : 'http'
+        let store
+        try {
+          store = h(protocol, req, msg.response)
+        } catch (_) {}
+        // The channel is published in the same synchronous execution as the server's 'request'
+        // event: entering the store here makes the request listeners run inside the SERVER
+        // span's context (80 NIO-220). Ignored requests enter an empty store, so a keep-alive
+        // connection never carries the previous request's context.
+        if (store !== undefined) {
+          try {
+            context.enter(store)
+          } catch (_) {}
+        }
+      })
+      return
+    } catch (_) { /* fall back to wrapping */ }
+  }
+  if (process.versions.bun) {
+    wrapServerEmit(require('http').Server.prototype, 'http')
+    wrapServerEmit(require('https').Server.prototype, 'https')
+    return
+  }
+  wrapNetServerEmit()
+}
+
+/**
+ * Node 18: http.Server and https.Server (through tls.Server) inherit their emit from
+ * net.Server.prototype, which is already loaded (the IPC channel uses net): wrapping it there
+ * avoids loading http and https — https brings tls and crypto — at activation (NIO-024). Only
+ * 'request' events whose request is an http.IncomingMessage (HTTP/1 servers, not http2) count.
+ */
+function wrapNetServerEmit () {
+  const proto = require('net').Server.prototype
+  const own = Object.prototype.hasOwnProperty.call(proto, 'emit')
+  const parent = Object.getPrototypeOf(proto)
+  const inherited = own ? proto.emit : null
+  let IncomingMessage = null
+  proto.emit = function emit (event, req, res) {
+    const orig = inherited || parent.emit
+    if (event === 'request') {
+      const h = registry().handlers.request
+      if (h) {
+        if (IncomingMessage === null) IncomingMessage = require('http').IncomingMessage
+        if (req instanceof IncomingMessage) {
+          let store
+          try {
+            store = h(req.socket && req.socket.encrypted ? 'https' : 'http', req, res)
+          } catch (_) {}
+          // the request listeners run inside the SERVER span's context (80 NIO-220)
+          if (store !== undefined) return context.run(store, orig, this, arguments)
+        }
+      }
+    }
+    return orig.apply(this, arguments)
+  }
+}
+
+function installNet () {
+  const r = registry()
+  if (r.installed.net) return
+  r.installed.net = true
+  const net = require('net')
+  const proto = net.Socket.prototype
+  const origWrite = proto.write
+  proto.write = function write (chunk, encoding) {
+    const h = registry().handlers.socketWrite
+    if (h && chunk) {
+      try {
+        h(typeof chunk === 'string' ? Buffer.byteLength(chunk, typeof encoding === 'string' ? encoding : 'utf8') : (chunk.length || 0))
+      } catch (_) {}
+    }
+    return origWrite.apply(this, arguments)
+  }
+  // Every received chunk passes through push() exactly once (80 A.4.5 quirk fixed).
+  const origPush = proto.push
+  proto.push = function push (chunk) {
+    const h = registry().handlers.socketRead
+    if (h && chunk) {
+      try {
+        h(chunk.length || 0)
+      } catch (_) {}
+    }
+    return origPush.apply(this, arguments)
+  }
+}
+
+function setHandler (name, fn) {
+  registry().handlers[name] = fn
+}
+
+module.exports = { installHttpServers, installNet, setHandler, registry }

package/lib/inbound.js

@@ -0,0 +1,174 @@
+// Copyright (c) 2026 Mike Warriner. All rights reserved. Proprietary — see LICENSE.
+'use strict'
+
+// Inbound HTTP requests, shared by the HTTP metrics (A.4.4), the SERVER spans (NIO-220/221) and
+// the framework exception reports (NIO-223). One process-wide interception (hooks.js) calls the
+// active consumers; a per-request state object travels on the request and the response.
+//
+// The state: { protocol, req, res, span, store, route, routeFn, error, info, start, done }.
+// Framework integrations find it with stateOf(req|res) and set `routeFn` (read when the
+// response starts, NIO-221) and `error`/`info` (NIO-223).
+
+const hooks = require('./hooks')
+const context = require('./tracing/context')
+
+const STATE = Symbol.for('@pmx/io:request-state')
+
+const consumers = { metrics: null, tracing: null, errors: null }
+let installedWriteHead = false
+
+function stateOf (obj) {
+  return obj ? obj[STATE] : undefined
+}
+
+function attach (obj, st) {
+  // a symbol-keyed property: invisible to Object.keys/JSON, and much cheaper than defineProperty
+  try {
+    obj[STATE] = st
+  } catch (_) {}
+}
+
+function anyConsumer () {
+  return Boolean(consumers.metrics || consumers.tracing || consumers.errors)
+}
+
+/** Read the framework route when the response starts (NIO-221). */
+function captureRoute (st) {
+  if (!st || st.route !== undefined) return
+  let route
+  try {
+    if (st.routeFn) route = st.routeFn()
+    if (route === undefined || route === null) {
+      // Express (and NestJS on Express): req.baseUrl + req.route.path
+      const req = st.req
+      if (req && req.route && typeof req.route.path === 'string') route = (req.baseUrl || '') + req.route.path
+    }
+  } catch (_) {
+    route = undefined
+  }
+  if (typeof route === 'string' && route !== '') st.route = route
+}
+
+function installWriteHead (res) {
+  if (installedWriteHead) return
+  let proto = Object.getPrototypeOf(res)
+  while (proto && !Object.prototype.hasOwnProperty.call(proto, 'writeHead')) proto = Object.getPrototypeOf(proto)
+  if (!proto) return
+  installedWriteHead = true
+  const r = hooks.registry()
+  if (r.installed.writeHead) return
+  r.installed.writeHead = true
+  const orig = proto.writeHead
+  const wrapped = function writeHead () {
+    const st = this[STATE]
+    if (st && !st.done) captureRoute(st)
+    return orig.apply(this, arguments)
+  }
+  Object.defineProperty(wrapped, 'length', { value: orig.length })
+  Object.defineProperty(wrapped, 'name', { value: orig.name })
+  proto.writeHead = wrapped
+}
+
+/**
+ * NIO-203: the request's and the response's events ('data', 'end', 'finish', 'close', …) run in
+ * the SERVER span's context. They are emitted from the connection's I/O callbacks, which carry
+ * the context the connection was created in: on Node with async context frames (24+) and on
+ * the `emit`-wrapping path (Node 18, Bun) a handler continued from a body parser's 'end'
+ * listener would otherwise run without the span. Installed once, on the first traced request:
+ * an own `emit` on IncomingMessage.prototype and ServerResponse.prototype that runs the
+ * inherited one inside the request's store (requests without a state are untouched).
+ */
+function installEmitBinding () {
+  const r = hooks.registry()
+  if (r.installed.emitBinding) return
+  r.installed.emitBinding = true
+  let http
+  try {
+    http = require('http')
+  } catch (_) {
+    return
+  }
+  for (const Cls of [http.IncomingMessage, http.ServerResponse]) {
+    const proto = Cls && Cls.prototype
+    if (!proto || Object.prototype.hasOwnProperty.call(proto, 'emit')) continue
+    const parent = Object.getPrototypeOf(proto)
+    const emit = function emit () {
+      const st = this[STATE]
+      const store = st && st.store
+      // the inherited emit is looked up on every call, so later patches of it still apply
+      if (store === undefined || !context.active()) return parent.emit.apply(this, arguments)
+      return context.run(store, parent.emit, this, arguments)
+    }
+    try {
+      Object.defineProperty(emit, 'length', { value: parent.emit.length })
+      Object.defineProperty(proto, 'emit', { value: emit, writable: true, configurable: true, enumerable: false })
+    } catch (_) {}
+  }
+}
+
+function finish (st, aborted) {
+  if (st.done) return
+  st.done = true
+  captureRoute(st)
+  const status = st.res && typeof st.res.statusCode === 'number' ? st.res.statusCode : undefined
+  if (consumers.errors && status >= 500 && st.error) {
+    try {
+      consumers.errors.report(st, status)
+    } catch (_) {}
+  }
+  if (st.span && consumers.tracing) {
+    try {
+      consumers.tracing.endServer(st, status, aborted)
+    } catch (_) {}
+  }
+}
+
+/** The process-wide request handler (hooks.js). Returns the store to run listeners in. */
+function onRequest (protocol, req, res) {
+  const m = consumers.metrics
+  if (m) {
+    try {
+      m.request(protocol, req, res)
+    } catch (_) {}
+  }
+  if (!consumers.tracing && !consumers.errors) return undefined
+  if (!res || typeof res.once !== 'function') return undefined
+  const prev = req[STATE]
+  if (prev && !prev.done) return prev.store // the same request seen twice (nested servers)
+  const st = { protocol, req, res, span: null, store: undefined, route: undefined, routeFn: null, error: null, info: null, done: false }
+  attach(req, st)
+  attach(res, st)
+  if (consumers.tracing) {
+    try {
+      consumers.tracing.startServer(st)
+    } catch (_) {}
+  }
+  installWriteHead(res)
+  if (st.store !== undefined) installEmitBinding()
+  // 'close' always follows 'finish'; writableFinished tells an aborted response apart
+  res.once('close', () => finish(st, !res.writableFinished))
+  return st.store
+}
+
+function refresh () {
+  if (anyConsumer()) {
+    hooks.installHttpServers()
+    hooks.setHandler('request', onRequest)
+  } else {
+    hooks.setHandler('request', null)
+  }
+}
+
+function setConsumer (name, value) {
+  consumers[name] = value || null
+  refresh()
+}
+
+/** The state of the request being served in the current context (Bun.serve, Hono on Bun). */
+function currentState () {
+  if (!context.active()) return undefined
+  const store = context.current()
+  return store && store.server ? store.server[STATE] : undefined
+}
+
+module.exports = { STATE, stateOf, attach, setConsumer, consumers, captureRoute, finish, currentState }

package/lib/integrations.js

@@ -0,0 +1,372 @@
+// Copyright (c) 2026 Mike Warriner. All rights reserved. Proprietary — see LICENSE.
+'use strict'
+
+// Framework integrations (80 NIO-221 route names, NIO-223 framework exceptions): Express 4/5,
+// Koa 2/3, Fastify 4/5, NestJS 10/11, h3 1.x (Nitro/Nuxt), Hono 4. Next.js needs none (its
+// requests reach the Node http server; names follow Part G.2). Bun.serve is bun.js.
+//
+// Every integration only observes: it records on the request state of inbound.js the route
+// (`routeFn`, read when the response starts) and the error the framework turned into a response
+// (`error`, reported by the errors consumer when the status is ≥ 500). Nothing is added to a
+// framework's public middleware lists (NIO-224).
+
+const inbound = require('./inbound')
+const debug = require('./debug')('axm:tracing')
+
+const HONO_INSTANCE = Symbol.for('@pmx/io:hono')
+
+function copyMeta (fn, orig) {
+  try {
+    Object.defineProperty(fn, 'length', { value: orig.length })
+    Object.defineProperty(fn, 'name', { value: orig.name })
+  } catch (_) {}
+  return fn
+}
+
+function wrapMethod (proto, name, make) {
+  if (!proto || typeof proto[name] !== 'function') return false
+  const orig = proto[name]
+  if (orig.__pmxWrapped) return false
+  const w = copyMeta(make(orig), orig)
+  Object.defineProperty(w, '__pmxWrapped', { value: true })
+  proto[name] = w
+  return true
+}
+
+function userId (u) {
+  return u && typeof u === 'object' && u.id !== undefined ? u.id : undefined
+}
+
+/** Record the error a framework turned into a response (reported at finish when ≥ 500). */
+function record (st, err, info) {
+  if (!st || st.done || err === undefined || err === null) return
+  st.error = err
+  if (info) st.info = info
+}
+
+// ---------------------------------------------------------------------------------------------
+// Express 4 (express/lib/router/layer.js) and Express 5 (router/lib/layer.js)
+
+function expressInfo (req) {
+  return { params: req.params, query: req.query, user: userId(req.user) }
+}
+
+function wrapNext (st, req, next) {
+  if (typeof next !== 'function') return next
+  return function next2 (err) {
+    if (err && err !== 'route' && err !== 'router') record(st, err, expressInfo(req))
+    return next.apply(this, arguments)
+  }
+}
+
+function patchLayer (Layer, names) {
+  const proto = Layer && Layer.prototype
+  if (!proto) return
+  wrapMethod(proto, names.request, (orig) => function (req, res, next) {
+    const st = inbound.stateOf(req)
+    if (!st) return orig.apply(this, arguments)
+    return orig.call(this, req, res, wrapNext(st, req, next))
+  })
+  wrapMethod(proto, names.error, (orig) => function (error, req, res, next) {
+    const st = inbound.stateOf(req)
+    if (!st) return orig.apply(this, arguments)
+    record(st, error, expressInfo(req))
+    return orig.call(this, error, req, res, wrapNext(st, req, next))
+  })
+}
+
+// ---------------------------------------------------------------------------------------------
+// Koa (Application.prototype.createContext)
+
+function patchKoa (Application) {
+  const proto = Application && Application.prototype
+  wrapMethod(proto, 'createContext', (orig) => function (req, res) {
+    const ctx = orig.apply(this, arguments)
+    const st = inbound.stateOf(req)
+    if (st && ctx) {
+      st.routeFn = () => ctx._matchedRoute
+      const protoOnerror = ctx.onerror
+      if (typeof protoOnerror === 'function') {
+        ctx.onerror = function onerror (err) {
+          if (err) {
+            const status = err.status || err.statusCode
+            if (!(typeof status === 'number' && status < 500)) {
+              record(st, err, { params: ctx.params, query: ctx.query, user: userId(ctx.state && ctx.state.user) })
+            }
+          }
+          return protoOnerror.apply(this, arguments)
+        }
+      }
+    }
+    return ctx
+  })
+}
+
+// ---------------------------------------------------------------------------------------------
+// Fastify (diagnostics channel `fastify.initialization`: hooks added to each new instance)
+
+function onFastify (instance) {
+  if (!instance || typeof instance.addHook !== 'function') return
+  try {
+    instance.addHook('onRequest', function pmxIoOnRequest (request, reply, done) {
+      const st = inbound.stateOf(request.raw)
+      if (st) {
+        st.routeFn = () => {
+          if (request.is404) return undefined
+          const ro = request.routeOptions
+          return (ro && ro.url) || request.routerPath || (request.routeConfig && request.routeConfig.url)
+        }
+      }
+      done()
+    })
+    instance.addHook('onError', function pmxIoOnError (request, reply, error, done) {
+      const st = inbound.stateOf(request.raw)
+      if (st) record(st, error, { params: request.params, query: request.query, user: userId(request.user) })
+      done()
+    })
+  } catch (err) {
+    debug('fastify hooks failed: %s', err && err.message)
+  }
+}
+
+// ---------------------------------------------------------------------------------------------
+// NestJS (BaseExceptionFilter.prototype.handleUnknownError)
+
+function patchNestFilter (exports) {
+  const BaseExceptionFilter = exports && exports.BaseExceptionFilter
+  wrapMethod(BaseExceptionFilter && BaseExceptionFilter.prototype, 'handleUnknownError', (orig) => function (exception, host) {
+    try {
+      const req = host && typeof host.switchToHttp === 'function' ? host.switchToHttp().getRequest() : undefined
+      const raw = req && req.raw ? req.raw : req
+      const st = inbound.stateOf(raw)
+      if (st && req) record(st, exception, { params: req.params, query: req.query, user: userId(req.user) })
+    } catch (_) {}
+    return orig.apply(this, arguments)
+  })
+}
+
+// ---------------------------------------------------------------------------------------------
+// h3 1.x (createApp options: onRequest / onError observers)
+
+function patchH3 (exports) {
+  const orig = exports && exports.createApp
+  if (typeof orig !== 'function') return undefined
+  const createApp = copyMeta(function createApp (options) {
+    const opts = Object.assign({}, options || {})
+    const userOnRequest = opts.onRequest
+    const userOnError = opts.onError
+    opts.onRequest = function onRequest (event) {
+      try {
+        const st = inbound.stateOf(event && event.node && event.node.req)
+        if (st) {
+          st.routeFn = () => {
+            const m = event.context && event.context.matchedRoute
+            return m && typeof m.path === 'string' ? m.path : undefined
+          }
+        }
+      } catch (_) {}
+      return userOnRequest ? userOnRequest.apply(this, arguments) : undefined
+    }
+    opts.onError = function onError (error, event) {
+      try {
+        const st = inbound.stateOf(event && event.node && event.node.req)
+        const status = error && (error.statusCode || error.status)
+        if (st && !(typeof status === 'number' && status < 500)) {
+          const original = error && error.cause instanceof Error ? error.cause : error
+          record(st, original, { params: event.context && event.context.params, query: undefined, user: undefined })
+        }
+      } catch (_) {}
+      return userOnError ? userOnError.apply(this, arguments) : undefined
+    }
+    return orig.call(this, opts)
+  }, orig)
+  const desc = Object.getOwnPropertyDescriptor(exports, 'createApp')
+  if (desc && desc.writable && !Object.isFrozen(exports)) {
+    exports.createApp = createApp
+    return undefined
+  }
+  return replaceExport(exports, 'createApp', createApp)
+}
+
+// ---------------------------------------------------------------------------------------------
+// Hono 4 (class Hono: per-instance fetch, router.match and errorHandler observers)
+
+let pendingDispatch = null
+
+function honoRoute (matchResult) {
+  try {
+    const list = Array.isArray(matchResult) ? matchResult[0] : null
+    if (!Array.isArray(list)) return undefined
+    const routes = []
+    for (const e of list) {
+      const hr = Array.isArray(e) ? e[0] : undefined
+      const rr = Array.isArray(hr) ? hr[1] : undefined
+      if (rr && typeof rr.path === 'string') routes.push(rr)
+    }
+    for (let i = routes.length - 1; i >= 0; i--) if (routes[i].method !== 'ALL') return routes[i].path
+    for (let i = routes.length - 1; i >= 0; i--) if (!routes[i].path.endsWith('*')) return routes[i].path
+    return undefined
+  } catch (_) {
+    return undefined
+  }
+}
+
+function honoState (env) {
+  const incoming = env && env.incoming
+  return (incoming && inbound.stateOf(incoming)) || inbound.currentState()
+}
+
+const routers = new WeakSet()
+function wrapRouter (router) {
+  if (!router || typeof router.match !== 'function' || routers.has(router)) return
+  routers.add(router)
+  const orig = router.match
+  router.match = copyMeta(function match () {
+    const r = orig.apply(this, arguments)
+    if (pendingDispatch && !pendingDispatch.result) pendingDispatch.result = r
+    return r
+  }, orig)
+}
+
+const errorWrappers = new WeakMap()
+const errorOriginals = new WeakMap() // wrapper → the app's handler
+// Hono's own default error handler(s), as found on new instances: while Hono's route() or
+// basePath() runs, an instance's errorHandler reads as the raw default, because route() decides
+// by identity (`app.errorHandler === errorHandler`) whether a sub-app's routes keep their
+// errors for the parent's onError (NIO-224 transparency).
+const honoDefaults = new WeakSet()
+let honoInternal = 0
+
+function unwrapHandler (h) {
+  return (typeof h === 'function' && errorOriginals.get(h)) || h
+}
+
+function wrapErrorHandler (handler) {
+  if (typeof handler !== 'function') return handler
+  handler = unwrapHandler(handler)
+  let w = errorWrappers.get(handler)
+  if (!w) {
+    w = copyMeta(function errorHandler (err, c) {
+      try {
+        const st = honoState(c && c.env)
+        const status = err && typeof err.getResponse === 'function' && typeof err.status === 'number' ? err.status : undefined
+        if (st && !(status !== undefined && status < 500)) record(st, err, { params: undefined, query: undefined, user: undefined })
+      } catch (_) {}
+      return handler.apply(this, arguments)
+    }, handler)
+    errorWrappers.set(handler, w)
+    errorOriginals.set(w, handler)
+  }
+  return w
+}
+
+/** route() and basePath() of Hono's base prototype: see honoDefaults; clones are instrumented. */
+function patchHonoProto (app) {
+  let proto = Object.getPrototypeOf(app)
+  while (proto && !Object.prototype.hasOwnProperty.call(proto, 'route')) proto = Object.getPrototypeOf(proto)
+  if (!proto) return
+  const internal = (orig, after) => function () {
+    honoInternal++
+    try {
+      const r = orig.apply(this, arguments)
+      return after ? after(r) : r
+    } finally {
+      honoInternal--
+    }
+  }
+  wrapMethod(proto, 'route', (orig) => internal(orig))
+  // basePath() returns a clone made inside Hono (not through the exported class): wrap it too
+  wrapMethod(proto, 'basePath', (orig) => internal(orig, (clone) => (clone && typeof clone === 'object' ? wrapHonoInstance(clone) : clone)))
+}
+
+function wrapHonoInstance (app) {
+  if (!app || app[HONO_INSTANCE]) return app
+  Object.defineProperty(app, HONO_INSTANCE, { value: true })
+  patchHonoProto(app)
+  wrapRouter(app.router)
+  const origFetch = app.fetch
+  if (typeof origFetch === 'function') {
+    app.fetch = copyMeta(function fetch (request, env) {
+      const holder = { result: null }
+      const prev = pendingDispatch
+      pendingDispatch = holder
+      let r
+      try {
+        r = origFetch.apply(this, arguments)
+      } finally {
+        pendingDispatch = prev
+        try {
+          const route = holder.result ? honoRoute(holder.result) : undefined
+          const st = honoState(env)
+          if (st && route) st.routeFn = () => route
+        } catch (_) {}
+      }
+      return r
+    }, origFetch)
+  }
+  let handler = unwrapHandler(app.errorHandler)
+  // a new instance (not a clone, whose handler was copied from its parent) holds Hono's default
+  if (honoInternal === 0 && typeof handler === 'function') honoDefaults.add(handler)
+  try {
+    Object.defineProperty(app, 'errorHandler', {
+      configurable: true,
+      enumerable: true,
+      get () { return honoInternal > 0 && honoDefaults.has(handler) ? handler : wrapErrorHandler(handler) },
+      set (v) { handler = unwrapHandler(v) }
+    })
+  } catch (_) {}
+  return app
+}
+
+function patchHono (exports) {
+  const Hono = exports && exports.Hono
+  if (typeof Hono !== 'function') return undefined
+  const P = new Proxy(Hono, {
+    construct (target, args, newTarget) {
+      return wrapHonoInstance(Reflect.construct(target, args, newTarget))
+    }
+  })
+  return replaceExport(exports, 'Hono', P)
+}
+
+// ---------------------------------------------------------------------------------------------
+
+/** A copy of `exports` whose `name` is `value` (other properties keep their descriptors). */
+function replaceExport (exports, name, value) {
+  const desc = Object.getOwnPropertyDescriptor(exports, name)
+  if (desc && desc.writable && desc.configurable !== false && !Object.isFrozen(exports)) {
+    exports[name] = value
+    return undefined
+  }
+  if (desc && desc.configurable) {
+    Object.defineProperty(exports, name, { value, writable: true, enumerable: desc.enumerable, configurable: true })
+    return undefined
+  }
+  const out = {}
+  for (const k of Reflect.ownKeys(exports)) {
+    if (k === name) continue
+    const d = Object.getOwnPropertyDescriptor(exports, k)
+    try {
+      Object.defineProperty(out, k, d)
+    } catch (_) {}
+  }
+  Object.defineProperty(out, name, { value, writable: true, enumerable: true, configurable: true })
+  return out
+}
+
+function list () {
+  return [
+    { pkg: 'express', for: 'both', files: { 'lib/router/layer.js': (L) => patchLayer(L, { request: 'handle_request', error: 'handle_error' }) } },
+    { pkg: 'router', for: 'both', files: { 'lib/layer.js': (L) => patchLayer(L, { request: 'handleRequest', error: 'handleError' }) } },
+    { pkg: 'koa', for: 'both', files: { 'lib/application.js': patchKoa }, eager: ['lib/application.js'] },
+    { pkg: '@nestjs/core', for: 'both', files: { 'exceptions/base-exception-filter.js': patchNestFilter }, eager: ['exceptions/base-exception-filter.js'] },
+    { pkg: 'h3', for: 'both', files: { 'dist/index.cjs': patchH3, 'dist/index.mjs': patchH3 } },
+    {
+      pkg: 'hono',
+      for: 'both',
+      files: { 'dist/cjs/hono.js': patchHono, 'dist/hono.js': patchHono }
+    }
+  ].concat(require('./tracing/logs').integrations(), require('./itg').list())
+}
+
+module.exports = { list, record, honoRoute, replaceExport, wrapHonoInstance, onFastify }