azify-logger 1.0.44 → 1.0.45

package/register-http-client-early.js

@@ -0,0 +1,816 @@
+'use strict'
+if (process.env.AZIFY_LOGGER_DISABLE === '1') return
+try {
+  const HTTP_DEBUG = process.env.AZIFY_LOGGER_HTTP_DEBUG === '1' || process.env.AZIFY_LOGGER_DEBUG === '1'
+  function httpLog(msg) {
+    if (HTTP_DEBUG) try { process.stderr.write('[AZIFY-HTTP] ' + msg + '\n') } catch (_) {}
+  }
+  if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+    try { process.stderr.write('[azify-logger] register-http-client-early: module loading\n') } catch (_) {}
+  }
+  const Module = require('module')
+  const path = require('path')
+  const EARLY_DIR = __dirname
+
+  function getOtelTraceContext() {
+    try {
+      const otelApi = require('@opentelemetry/api')
+      const span = otelApi.trace.getSpan(otelApi.context.active())
+      if (!span) return null
+      const ctx = span.spanContext()
+      return ctx && ctx.traceId ? { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId || null } : null
+    } catch (_) {
+      return null
+    }
+  }
+
+  const HTTP_VERBOSE = process.env.AZIFY_LOGGER_HTTP_VERBOSE === '1'
+  const MAX_EARLY_LOG_QUEUE = 2000
+  const earlyLogQueue = []
+
+  function isLoggerUrl(urlStr) {
+    const loggerUrl = process.env.AZIFY_LOGGER_URL
+    if (!loggerUrl || typeof urlStr !== 'string' || !urlStr.trim()) return false
+    const a = String(urlStr).trim().toLowerCase().replace(/\/+$/, '')
+    const b = String(loggerUrl).trim().toLowerCase().replace(/\/+$/, '')
+    if (!b) return false
+    return a === b || a.startsWith(b + '/')
+  }
+
+  function send(level, message, meta) {
+    try {
+      const msgStr = String(message)
+      const isReqRes = msgStr.indexOf('[REQUEST]') !== -1 || msgStr.indexOf('[RESPONSE]') !== -1
+      if (HTTP_VERBOSE && isReqRes) {
+        try { process.stderr.write('[AZIFY] HTTP send ' + msgStr.slice(0, 70) + ' global=' + (typeof global.__AZIFY_SEND_OUTBOUND_LOG === 'function') + '\n') } catch (_) {}
+      }
+      const fn = typeof global.__AZIFY_SEND_OUTBOUND_LOG === 'function' ? global.__AZIFY_SEND_OUTBOUND_LOG : null
+      if (isReqRes && (HTTP_VERBOSE || process.env.AZIFY_LOGGER_DEBUG === '1')) {
+        try { process.stderr.write('[AZIFY-DBG] early.send ' + msgStr.slice(0, 50) + ' hasFn=' + !!fn + ' queueLen=' + earlyLogQueue.length + '\n') } catch (_) {}
+      }
+      if (fn) {
+        if (meta && meta.__source === 'http-client') {
+          httpLog('SEND -> ' + msgStr.slice(0, 90))
+        }
+        fn(level, message, meta)
+      } else {
+        if (meta && meta.__source === 'http-client') httpLog('SEND_QUEUED (no global yet) ' + msgStr.slice(0, 60))
+        if (earlyLogQueue.length >= MAX_EARLY_LOG_QUEUE) earlyLogQueue.shift()
+        earlyLogQueue.push({ level, message, meta })
+      }
+    } catch (_) {}
+  }
+  function flushEarlyLogQueue() {
+    const fn = typeof global.__AZIFY_SEND_OUTBOUND_LOG === 'function' ? global.__AZIFY_SEND_OUTBOUND_LOG : null
+    if (!fn || !earlyLogQueue.length) return
+    const n = earlyLogQueue.length
+    httpLog('FLUSH_QUEUE n=' + n)
+    while (earlyLogQueue.length) {
+      const entry = earlyLogQueue.shift()
+      try { fn(entry.level, entry.message, entry.meta) } catch (_) {}
+    }
+  }
+
+  let storeSamplingLoaded = null
+  function loadStoreAndSampling() {
+    if (storeSamplingLoaded !== null) return storeSamplingLoaded
+    try {
+      const store = require(path.join(EARLY_DIR, 'store'))
+      const sampling = require(path.join(EARLY_DIR, 'sampling'))
+      storeSamplingLoaded = {
+        getRequestContext: store.getRequestContext,
+        getLastJobContext: store.getLastJobContext,
+        toTraceIdHex: store.toTraceIdHex,
+        markSource: sampling.markSource,
+        HTTP_CLIENT_MODE: sampling.HTTP_CLIENT_MODE
+      }
+      if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+        try { process.stderr.write('[azify-logger] register-http-client-early: HTTP_CLIENT_MODE=' + storeSamplingLoaded.HTTP_CLIENT_MODE + '\n') } catch (_) {}
+      }
+      return storeSamplingLoaded
+    } catch (e) {
+      storeSamplingLoaded = false
+      if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+        try { process.stderr.write('[azify-logger] register-http-client-early: loadStoreAndSampling failed: ' + (e && e.message) + '\n') } catch (_) {}
+      }
+      return false
+    }
+  }
+
+  function patchUndiciExports(exports) {
+    const hasRequest = exports && typeof exports.request === 'function' && !exports.request.__azifyPatched
+    const hasFetch = exports && typeof exports.fetch === 'function' && !exports.fetch.__azifyPatched
+    if (!exports || (!hasRequest && !hasFetch)) return
+    const deps = loadStoreAndSampling()
+    const noDeps = !deps
+    if (noDeps && process.env.AZIFY_LOGGER_DEBUG === '1') {
+      try { process.stderr.write('[azify-logger] register-http-client-early: patching undici without deps (minimal wrapper)\n') } catch (_) {}
+    }
+    const getRequestContext = deps ? deps.getRequestContext : () => null
+    const getLastJobContext = deps ? deps.getLastJobContext : () => null
+    const toTraceIdHex = deps ? deps.toTraceIdHex : (x) => (typeof x === 'string' ? x : (x && String(x)) || '')
+    const markSource = deps ? deps.markSource : () => {}
+    const HTTP_CLIENT_MODE = deps ? deps.HTTP_CLIENT_MODE : 'all'
+    httpLog('PATCH_EXPORTS request=' + !!hasRequest + ' fetch=' + !!hasFetch + (noDeps ? ' noDeps=1' : ''))
+    if (HTTP_DEBUG) try { process.stderr.write('[AZIFY] undici PATCHED (request=' + !!hasRequest + ' fetch=' + !!hasFetch + ')\n') } catch (_) {}
+    if (hasRequest) {
+    const origRequest = exports.request
+    exports.request = function (url, options, callback) {
+      const opts = (typeof url === 'object' && url !== null && !(url instanceof URL)) ? url : options
+      const method = ((opts && opts.method) || 'GET').toUpperCase()
+      let urlStr = 'unknown'
+      const urlArg = (typeof url === 'string' || (url && (url.href || url instanceof URL))) ? url : (opts && (opts.url || opts.uri))
+      if (typeof urlArg === 'string') urlStr = urlArg
+      else if (urlArg && typeof urlArg.href === 'string') urlStr = urlArg.href
+      else if (urlArg && typeof urlArg.toString === 'function') urlStr = urlArg.toString()
+      else if (opts && typeof opts.origin === 'string' && opts.path != null) urlStr = opts.origin + (String(opts.path).startsWith('/') ? '' : '/') + String(opts.path)
+      if (process.env.AZIFY_LOGGER_DEBUG === '1') { try { process.stderr.write('[AZIFY-PATCH] undici.request ' + method + ' ' + urlStr.slice(0, 80) + '\n') } catch (_) {} }
+      const _ep = process.env.AZIFY_DEBUG_LOG_PATH
+      if (_ep) { try { require('fs').appendFileSync(_ep, new Date().toISOString() + ' [AZIFY] WRAPPER exports.request ' + method + ' ' + urlStr.slice(0, 100) + '\n') } catch (_) {} }
+      if (HTTP_VERBOSE || HTTP_DEBUG) {
+        try { process.stderr.write('[AZIFY] HTTP wrapper undici.request ' + method + ' ' + urlStr.slice(0, 80) + '\n') } catch (_) {}
+      }
+      httpLog('WRAPPER undici.request ' + method + ' ' + urlStr.slice(0, 80))
+      const ctx = getRequestContext() || getLastJobContext()
+      const otelCtx = getOtelTraceContext()
+      const traceCtx = ctx || otelCtx
+      const rawTraceId = traceCtx && traceCtx.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
+      const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+      const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method, url: urlStr }
+      markSource(requestMeta, 'http-client')
+      const start = require('perf_hooks').performance.now()
+      const skipLog = isLoggerUrl(urlStr)
+      if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${method} ${urlStr}`, requestMeta)
+      const wrappedCb = callback ? function (err, data) {
+        const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+        if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+          if (err) send('error', `[RESPONSE] ${method} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+          else if (data) send('info', `[RESPONSE] ${method} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+        }
+        return callback(err, data)
+      } : undefined
+      if (wrappedCb) return origRequest.call(this, url, options, wrappedCb)
+      const p = origRequest.call(this, url, options)
+      if (p && typeof p.then === 'function') {
+        return p.then(
+          (data) => {
+            const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) send('info', `[RESPONSE] ${method} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+            return data
+          },
+          (err) => {
+            const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('error', `[RESPONSE] ${method} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+            throw err
+          }
+        )
+      }
+      return p
+    }
+    exports.request.__azifyPatched = true
+    }
+    if (exports.Dispatcher && exports.Dispatcher.prototype && typeof exports.Dispatcher.prototype.request === 'function' && !exports.Dispatcher.prototype.request.__azifyPatched) {
+      const proto = exports.Dispatcher.prototype
+      const origDisp = proto.request
+      proto.request = function (opts, callback) {
+        const methodStr = String((opts && opts.method) || 'GET').toUpperCase()
+        const origin = (opts && opts.origin) || ''
+        const path = (opts && opts.path) != null ? opts.path : '/'
+        const urlStr = origin ? (origin + (path.startsWith('/') ? path : '/' + path)) : 'unknown'
+        httpLog('WRAPPER Dispatcher.request ' + methodStr + ' ' + urlStr.slice(0, 80))
+        const ctx = getRequestContext() || getLastJobContext()
+        const otelCtx = getOtelTraceContext()
+        const traceCtx = ctx || otelCtx
+        const rawTraceId = (traceCtx && traceCtx.traceId) || (require('crypto').randomUUID && require('crypto').randomUUID())
+        const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+        const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method: methodStr, url: urlStr }
+        markSource(requestMeta, 'http-client')
+        const start = require('perf_hooks').performance.now()
+        const skipLog = isLoggerUrl(urlStr)
+        if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${methodStr} ${urlStr}`, requestMeta)
+        const wrappedCb = typeof callback === 'function' ? function (err, data) {
+          const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+          if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+            if (err) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+            else if (data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+          }
+          return callback(err, data)
+        } : undefined
+        const ret = wrappedCb ? origDisp.call(this, opts, wrappedCb) : origDisp.call(this, opts)
+        if (ret && typeof ret.then === 'function' && !wrappedCb) {
+          return ret.then(
+            (data) => {
+              const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+              return data
+            },
+            (err) => {
+              const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+              throw err
+            }
+          )
+        }
+        return ret
+      }
+      proto.request.__azifyPatched = true
+    }
+    if (typeof exports.fetch === 'function' && !exports.fetch.__azifyPatched && deps) {
+      const origFetch = exports.fetch
+      exports.fetch = function (input, init) {
+        const methodStr = String((init && init.method) || 'GET').toUpperCase()
+        const urlStr = typeof input === 'string' ? input : (input && (input.url || input.href)) ? String(input.url || input.href) : String(input)
+        httpLog('WRAPPER undici.fetch ' + methodStr + ' ' + urlStr.slice(0, 80))
+        const ctx = getRequestContext() || getLastJobContext()
+        const otelCtx = getOtelTraceContext()
+        const traceCtx = ctx || otelCtx
+        const rawTraceId = traceCtx && traceCtx.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
+        const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+        const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method: methodStr, url: urlStr }
+        markSource(requestMeta, 'http-client')
+        const start = require('perf_hooks').performance.now()
+        const skipLog = isLoggerUrl(urlStr)
+        if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${methodStr} ${urlStr}`, requestMeta)
+        return origFetch.apply(this, arguments).then(
+          function (response) {
+            const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog && response) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${response.status} ${duration}ms`, { ...requestMeta, statusCode: response.status, responseTimeMs: duration })
+            return response
+          },
+          function (err) {
+            const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+            throw err
+          }
+        )
+      }
+      exports.fetch.__azifyPatched = true
+    }
+    if (exports.getGlobalDispatcher && typeof exports.getGlobalDispatcher === 'function' && !exports.getGlobalDispatcher.__azifyPatched) {
+      const origGetGlobal = exports.getGlobalDispatcher
+      exports.getGlobalDispatcher = function getGlobalDispatcherPatched() {
+        const d = origGetGlobal.call(this)
+        if (!d || (d.request && d.request.__azifyPatched)) return d
+        const origReq = d.request
+        if (typeof origReq !== 'function') return d
+        d.request = function (opts, callback) {
+          const methodStr = String((opts && opts.method) || 'GET').toUpperCase()
+          const origin = (opts && opts.origin) || ''
+          const pathPart = (opts && opts.path) != null ? opts.path : '/'
+          const urlStr = origin ? (origin + (pathPart.startsWith('/') ? pathPart : '/' + pathPart)) : 'unknown'
+          httpLog('WRAPPER getGlobalDispatcher().request ' + methodStr + ' ' + urlStr.slice(0, 80))
+          const ctx = getRequestContext ? getRequestContext() : (getLastJobContext ? getLastJobContext() : null)
+          const otelCtx = getOtelTraceContext()
+          const traceCtx = ctx || otelCtx
+          const rawTraceId = (traceCtx && traceCtx.traceId) || (require('crypto').randomUUID && require('crypto').randomUUID())
+          const traceId = typeof rawTraceId === 'string' ? (toTraceIdHex ? toTraceIdHex(rawTraceId) : rawTraceId) : rawTraceId
+          const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method: methodStr, url: urlStr }
+          if (markSource) markSource(requestMeta, 'http-client')
+          const start = require('perf_hooks').performance.now()
+          const skipLog = isLoggerUrl(urlStr)
+          if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${methodStr} ${urlStr}`, requestMeta)
+          const wrappedCb = typeof callback === 'function' ? function (err, data) {
+            const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+              if (err) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+              else if (data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+            }
+            return callback(err, data)
+          } : undefined
+          const ret = wrappedCb ? origReq.call(this, opts, wrappedCb) : origReq.call(this, opts)
+          if (ret && typeof ret.then === 'function' && !wrappedCb) {
+            return ret.then(
+              (data) => {
+                const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+                if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                return data
+              },
+              (err) => {
+                const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+                if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+                throw err
+              }
+            )
+          }
+          return ret
+        }
+        d.request.__azifyPatched = true
+        return d
+      }
+      exports.getGlobalDispatcher.__azifyPatched = true
+      httpLog('PATCH_EXPORTS getGlobalDispatcher wrapped')
+    }
+    patchGlobalDispatcherInPlace()
+  }
+  let _globalDispatcherCheckTicks = 0
+  function patchGlobalDispatcherInPlace() {
+    try {
+      const sym = Symbol.for('undici.globalDispatcher.1')
+      const d = typeof globalThis !== 'undefined' && globalThis[sym]
+      _globalDispatcherCheckTicks++
+      if (HTTP_DEBUG && (_globalDispatcherCheckTicks <= 3 || _globalDispatcherCheckTicks % 20 === 0)) {
+        try {
+          const reqFromProto = d && Object.getPrototypeOf(d) && Object.getPrototypeOf(d).request
+          process.stderr.write('[AZIFY] GLOBAL_DISPATCHER_CHECK tick=' + _globalDispatcherCheckTicks + ' hasD=' + !!d + ' hasRequest=' + !!(d && typeof d.request === 'function') + ' protoRequest=' + (typeof reqFromProto === 'function') + ' alreadyPatched=' + !!(d && d.request && d.request.__azifyGlobalPatched) + '\n')
+        } catch (_) {}
+      }
+      if (!d) return
+      let origReq = null
+      if (typeof d.request === 'function') origReq = d.request
+      else {
+        let proto = Object.getPrototypeOf(d)
+        while (proto) {
+          if (typeof proto.request === 'function') { origReq = proto.request; break }
+          proto = Object.getPrototypeOf(proto)
+        }
+      }
+      if (!origReq || origReq.__azifyGlobalPatched) return
+      const deps = loadStoreAndSampling()
+      const getRequestContext = deps ? deps.getRequestContext : () => null
+      const getLastJobContext = deps ? deps.getLastJobContext : () => null
+      const toTraceIdHex = deps ? deps.toTraceIdHex : (x) => (typeof x === 'string' ? x : (x && String(x)) || '')
+      const markSource = deps ? deps.markSource : () => {}
+      const HTTP_CLIENT_MODE = deps ? deps.HTTP_CLIENT_MODE : 'all'
+      d.request = function (opts, callback) {
+        const methodStr = String((opts && opts.method) || 'GET').toUpperCase()
+        const origin = (opts && opts.origin) || ''
+        const pathPart = (opts && opts.path) != null ? opts.path : '/'
+        const urlStr = origin ? (origin + (pathPart.startsWith('/') ? pathPart : '/' + pathPart)) : 'unknown'
+        httpLog('WRAPPER globalThis.dispatcher.request ' + methodStr + ' ' + urlStr.slice(0, 80))
+        const _dp = process.env.AZIFY_DEBUG_LOG_PATH
+        if (_dp) { try { require('fs').appendFileSync(_dp, new Date().toISOString() + ' [AZIFY] WRAPPER globalDispatcher.request ' + methodStr + ' ' + urlStr.slice(0, 100) + '\n') } catch (_) {} }
+        const ctx = getRequestContext ? getRequestContext() : (getLastJobContext ? getLastJobContext() : null)
+        const otelCtx = getOtelTraceContext()
+        const traceCtx = ctx || otelCtx
+        const rawTraceId = (traceCtx && traceCtx.traceId) || (require('crypto').randomUUID && require('crypto').randomUUID())
+        const traceId = typeof rawTraceId === 'string' ? (toTraceIdHex ? toTraceIdHex(rawTraceId) : rawTraceId) : rawTraceId
+        const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method: methodStr, url: urlStr }
+        if (markSource) markSource(requestMeta, 'http-client')
+        const start = require('perf_hooks').performance.now()
+        const skipLog = isLoggerUrl(urlStr)
+        if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${methodStr} ${urlStr}`, requestMeta)
+        const wrappedCb = typeof callback === 'function' ? function (err, data) {
+          const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+          if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+            if (err) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+            else if (data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+          }
+          return callback(err, data)
+        } : undefined
+        const ret = wrappedCb ? origReq.call(this, opts, wrappedCb) : origReq.call(this, opts)
+        if (ret && typeof ret.then === 'function' && !wrappedCb) {
+          return ret.then(
+            (data) => {
+              const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+              return data
+            },
+            (err) => {
+              const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+              throw err
+            }
+          )
+        }
+        return ret
+      }
+      d.request.__azifyGlobalPatched = true
+      httpLog('PATCH_EXPORTS globalThis.dispatcher.request wrapped')
+      try { process.stderr.write('[AZIFY] global dispatcher.request patchado — requests serão logados\n') } catch (_) {}
+      const debugLogPath = process.env.AZIFY_DEBUG_LOG_PATH
+      if (debugLogPath) {
+        try { require('fs').appendFileSync(debugLogPath, new Date().toISOString() + ' [AZIFY] global dispatcher patchado\n') } catch (_) {}
+      }
+    } catch (e) {
+      if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+        try { process.stderr.write('[azify-logger] register-http-client-early: patch globalThis dispatcher: ' + (e && e.message) + '\n') } catch (_) {}
+      }
+    }
+  }
+
+  function isMainUndiciCacheKey(key) {
+    if (!key || typeof key !== 'string') return false
+    const k = key.replace(/\\/g, '/')
+    return k.indexOf('undici') !== -1 && k.indexOf('undici-package') === -1 && k.indexOf('undici/lib') === -1 && (k.endsWith('undici/index.js') || k.endsWith('undici.js'))
+  }
+
+  let patchedUndiciSingleton = null
+  function tryPatchAndProxyUndici(result, logLabel) {
+    if (!result || typeof result !== 'object') return null
+    if (result.request && result.request.__azifyPatched) {
+      patchedUndiciSingleton = result
+      return result
+    }
+    if (!result.request && !result.fetch) return null
+    const needsPatch = (typeof result.request === 'function' && !result.request.__azifyPatched) || (typeof result.fetch === 'function' && !result.fetch.__azifyPatched)
+    if (!needsPatch) return result
+    try {
+      patchUndiciExports(result)
+    } catch (e) {
+      if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+        try { process.stderr.write('[azify-logger] register-http-client-early: ' + logLabel + ' patch threw: ' + (e && e.message) + '\n') } catch (_) {}
+      }
+      return result
+    }
+    patchedUndiciSingleton = result
+    if (HTTP_DEBUG) try { process.stderr.write('[AZIFY-DBG] undici PATCHED (first load) label=' + (logLabel || 'REQUIRE') + '\n') } catch (_) {}
+    try {
+      const cache = require.cache
+      if (cache && typeof cache === 'object') {
+        for (const key of Object.keys(cache)) {
+          if (isMainUndiciCacheKey(key) && cache[key].exports !== result) {
+            cache[key].exports = result
+            httpLog('REQUIRE first-load sync cache -> singleton key=' + String(key).slice(-55))
+          }
+        }
+      }
+    } catch (_) {}
+    httpLog((logLabel || 'REQUIRE') + ' patched in place (no proxy)')
+    return result
+  }
+
+  const origRequire = Module.prototype.require
+  if (typeof origRequire === 'function' && !Module.prototype.require.__azifyEarlyPatched) {
+    Module.prototype.require = function (id) {
+      const idStr = typeof id === 'string' ? id : ''
+      const isUndiciId = idStr === 'undici' || (idStr.indexOf('undici') !== -1 && idStr.indexOf('undici-package') === -1)
+      let result
+      if (HTTP_DEBUG && isUndiciId && idStr) {
+        const caller = (this && typeof this.filename === 'string') ? this.filename : (this && this.id) || 'unknown'
+        try { process.stderr.write('[AZIFY] require("undici") caller=' + String(caller).replace(/\\/g, '/').slice(-100) + ' singleton=' + !!patchedUndiciSingleton + '\n') } catch (_) {}
+      }
+      if (HTTP_DEBUG && idStr && (idStr === 'undici' || idStr.includes('undici'))) {
+        const caller = (this && typeof this.filename === 'string') ? this.filename : (this && this.id) || 'unknown'
+        try { process.stderr.write('[AZIFY-DBG] require("' + idStr.slice(-70) + '") caller=' + String(caller).slice(-90) + ' singleton=' + !!patchedUndiciSingleton + '\n') } catch (_) {}
+      }
+      if (isUndiciId && patchedUndiciSingleton) {
+        try {
+          const cache = require.cache
+          if (cache && typeof cache === 'object') {
+            for (const key of Object.keys(cache)) {
+              if (isMainUndiciCacheKey(key) && cache[key].exports !== patchedUndiciSingleton) {
+                cache[key].exports = patchedUndiciSingleton
+                httpLog('REQUIRE undici cache[all main] -> singleton key=' + String(key).slice(-60))
+              }
+            }
+            try {
+              const resolvedPath = Module._resolveFilename(idStr, this, false)
+              if (resolvedPath && cache[resolvedPath]) cache[resolvedPath].exports = patchedUndiciSingleton
+            } catch (_) {}
+          }
+          if (typeof patchedUndiciSingleton.request === 'function' && !patchedUndiciSingleton.request.__azifyPatched) {
+            patchUndiciExports(patchedUndiciSingleton)
+          }
+          patchGlobalDispatcherInPlace()
+          return patchedUndiciSingleton
+        } catch (_) {}
+      }
+
+      result = origRequire.apply(this, arguments)
+      if (result && typeof result === 'object' && patchedUndiciSingleton && result !== patchedUndiciSingleton) {
+        const hasRequest = typeof result.request === 'function'
+        const hasDispatcher = result.Dispatcher && result.Dispatcher.prototype
+        if (hasRequest && hasDispatcher && (result.fetch || result.Pool)) {
+          try {
+            const cache = require.cache
+            if (cache && typeof cache === 'object') {
+              for (const key of Object.keys(cache)) {
+                if (cache[key].exports === result) {
+                  cache[key].exports = patchedUndiciSingleton
+                  httpLog('REQUIRE by-result -> singleton key=' + String(key).slice(-55))
+                  break
+                }
+              }
+            }
+          } catch (_) {}
+          return patchedUndiciSingleton
+        }
+      }
+      if (!isUndiciId) {
+        return result
+      }
+      httpLog('REQUIRE undici id=' + idStr.slice(-60) + ' singleton=' + !!patchedUndiciSingleton)
+      if (patchedUndiciSingleton && result !== patchedUndiciSingleton) {
+        try {
+          const cache = require.cache
+          if (cache && typeof cache === 'object') {
+            let resolvedPath
+            try { resolvedPath = Module._resolveFilename(idStr, this, false) } catch (_) {}
+            if (resolvedPath && cache[resolvedPath]) cache[resolvedPath].exports = patchedUndiciSingleton
+            for (const key of Object.keys(cache)) {
+              if (cache[key].exports === result) {
+                cache[key].exports = patchedUndiciSingleton
+                httpLog('REQUIRE undici cache -> singleton key=' + String(key).slice(-60))
+                break
+              }
+            }
+          }
+          if (typeof patchedUndiciSingleton.request === 'function' && !patchedUndiciSingleton.request.__azifyPatched) {
+            patchUndiciExports(patchedUndiciSingleton)
+          }
+          patchGlobalDispatcherInPlace()
+        } catch (_) {}
+        return patchedUndiciSingleton
+      }
+      if (result && (result.request || result.fetch) && !result.request?.__azifyPatched) {
+        const prox = tryPatchAndProxyUndici(result, 'REQUIRE')
+        if (prox) return prox
+      }
+      let cacheKeyUndici = null
+      if (result && typeof result === 'object') {
+        try {
+          const cache = require.cache
+          if (cache && typeof cache === 'object') {
+            for (const key of Object.keys(cache)) {
+              const mod = cache[key]
+              if (mod && mod.exports === result && typeof key === 'string') {
+                const k = key.replace(/\\/g, '/')
+                if (k.indexOf('undici') !== -1 && k.indexOf('undici-package') === -1) {
+                  cacheKeyUndici = key
+                  break
+                }
+              }
+            }
+          }
+        } catch (_) {}
+      }
+      if (cacheKeyUndici && isUndiciShaped(result)) {
+        const kNorm = cacheKeyUndici.replace(/\\/g, '/')
+        const isMainUndiciEntry = (kNorm.endsWith('undici/index.js') || kNorm.endsWith('undici.js')) && kNorm.indexOf('undici/lib') === -1
+        if (isMainUndiciEntry && patchedUndiciSingleton) {
+          try {
+            const cache = require.cache
+            const mod = cache[cacheKeyUndici]
+            if (mod && mod.exports === result) {
+              mod.exports = patchedUndiciSingleton
+              httpLog('REQUIRE undici by path -> singleton id=' + idStr.slice(-50))
+            }
+          } catch (_) {}
+          return patchedUndiciSingleton
+        }
+        if (isMainUndiciEntry) {
+          const prox = tryPatchAndProxyUndici(result, 'REQUIRE(path)')
+          if (prox) {
+            httpLog('REQUIRE undici by path id=' + idStr.slice(-50))
+            return prox
+          }
+        }
+      }
+      return result
+    }
+    Module.prototype.require.__azifyEarlyPatched = true
+  }
+
+  const origLoad = Module._load
+  if (typeof origLoad === 'function' && !Module._load.__azifyEarlyPatched) {
+    Module._load = function (request, parent, isMain) {
+      const pathStr = typeof request === 'string' ? request.replace(/\\/g, '/') : ''
+      const isUndici = pathStr === 'undici' || (pathStr.indexOf('undici') !== -1 && pathStr.indexOf('undici-package') === -1)
+      if (HTTP_DEBUG && isUndici) {
+        try { process.stderr.write('[AZIFY] _LOAD undici path=' + pathStr.replace(/\\/g, '/').slice(-90) + ' parent=' + (parent && parent.filename ? String(parent.filename).replace(/\\/g, '/').slice(-80) : '') + '\n') } catch (_) {}
+      }
+      const isMainUndici = isUndici && pathStr.indexOf('undici/lib') === -1 && (pathStr === 'undici' || pathStr.endsWith('undici/index.js') || pathStr.endsWith('/undici.js'))
+      if (isUndici && patchedUndiciSingleton) {
+        const result = origLoad.apply(this, arguments)
+        try {
+          const cache = require.cache
+          if (cache && typeof cache === 'object' && result && typeof result === 'object') {
+            for (const key of Object.keys(cache)) {
+              const mod = cache[key]
+              if (mod && mod.exports === result) {
+                mod.exports = patchedUndiciSingleton
+                httpLog('_LOAD undici cache -> singleton key=' + String(key).slice(-60))
+                break
+              }
+            }
+          }
+        } catch (_) {}
+        return patchedUndiciSingleton
+      }
+      const result = origLoad.apply(this, arguments)
+      let returnValue = result
+      try {
+        let resolvedPath = pathStr
+        if (parent && parent.filename && typeof request === 'string') {
+          try { resolvedPath = Module._resolveFilename(request, parent, false) } catch (_) {}
+        }
+        const resolvedNorm = String(resolvedPath).replace(/\\/g, '/')
+        if (resolvedNorm.indexOf('undici') !== -1 && resolvedNorm.indexOf('api-request') !== -1 && resolvedNorm.indexOf('undici-package') === -1) {
+          const mod = require.cache[resolvedPath]
+          if (mod && mod.exports && typeof mod.exports === 'function' && !mod.exports.__azifyApiRequestPatched) {
+            const deps = loadStoreAndSampling()
+            const getRequestContext = deps ? deps.getRequestContext : () => null
+            const getLastJobContext = deps ? deps.getLastJobContext : () => null
+            const toTraceIdHex = deps ? deps.toTraceIdHex : (x) => (typeof x === 'string' ? x : (x && String(x)) || '')
+            const markSource = deps ? deps.markSource : () => {}
+            const HTTP_CLIENT_MODE = deps ? deps.HTTP_CLIENT_MODE : 'all'
+            const origRequest = mod.exports
+            const RequestHandler = mod.exports.RequestHandler
+            mod.exports = function wrappedApiRequest(opts, callback) {
+              const methodStr = String((opts && opts.method) || 'GET').toUpperCase()
+              const urlPart = (opts && opts.origin) ? String(opts.origin).slice(0, 80) : (opts && opts.path) || ''
+              if (HTTP_DEBUG) try { process.stderr.write('[AZIFY-PATCH] api-request ' + methodStr + ' ' + urlPart + '\n') } catch (_) {}
+              if (HTTP_VERBOSE || HTTP_DEBUG) {
+                try { process.stderr.write('[AZIFY] HTTP wrapper api-request ' + methodStr + ' ' + urlPart + '\n') } catch (_) {}
+              }
+              const origin = (opts && opts.origin) || ''
+              const pathPart = (opts && opts.path) != null ? opts.path : '/'
+              const urlStr = origin ? (origin + (pathPart.startsWith('/') ? pathPart : '/' + pathPart)) : 'unknown'
+              httpLog('WRAPPER api-request ' + methodStr + ' ' + urlStr.slice(0, 80))
+              const ctx = getRequestContext() || getLastJobContext()
+              const otelCtx = getOtelTraceContext()
+              const traceCtx = ctx || otelCtx
+              const rawTraceId = (traceCtx && traceCtx.traceId) || (require('crypto').randomUUID && require('crypto').randomUUID())
+              const traceId = typeof rawTraceId === 'string' ? (toTraceIdHex ? toTraceIdHex(rawTraceId) : rawTraceId) : rawTraceId
+              const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method: methodStr, url: urlStr }
+              if (markSource) markSource(requestMeta, 'http-client')
+              const start = require('perf_hooks').performance.now()
+              const skipLog = isLoggerUrl(urlStr)
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${methodStr} ${urlStr}`, requestMeta)
+              const wrappedCb = typeof callback === 'function' ? function (err, data) {
+                const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+                if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+                  if (err) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+                  else if (data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                }
+                return callback(err, data)
+              } : undefined
+              const ret = wrappedCb ? origRequest.call(this, opts, wrappedCb) : origRequest.call(this, opts)
+              if (ret && typeof ret.then === 'function' && !wrappedCb) {
+                return ret.then(
+                  (data) => {
+                    const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+                    if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                    return data
+                  },
+                  (err) => {
+                    const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+                    if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+                    throw err
+                  }
+                )
+              }
+              return ret
+            }
+            mod.exports.RequestHandler = RequestHandler
+            mod.exports.__azifyApiRequestPatched = true
+            returnValue = mod.exports
+            if (parent && parent.exports && typeof parent.exports === 'object') {
+              parent.exports.request = mod.exports
+              httpLog('_LOAD undici api-request.js: parent.exports.request = wrapper')
+            }
+            httpLog('_LOAD undici api-request.js patched (returning wrapper)')
+          }
+        }
+      } catch (e) {
+        if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+          try { process.stderr.write('[azify-logger] register-http-client-early: patch api-request: ' + (e && e.message) + '\n') } catch (_) {}
+        }
+      }
+      if (isUndici) {
+        httpLog('_LOAD undici path=' + pathStr.slice(-90))
+        try {
+          if (result && typeof result === 'object' && (result.request || result.fetch)) {
+            patchUndiciExports(result)
+            patchedUndiciSingleton = result
+            httpLog('_LOAD undici patched in place (no proxy)')
+          }
+        } catch (e) {
+          if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+            try { process.stderr.write('[azify-logger] register-http-client-early: patchUndiciExports threw: ' + (e && e.message) + '\n') } catch (_) {}
+          }
+        }
+      }
+      return returnValue
+    }
+    Module._load.__azifyEarlyPatched = true
+    if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+      try { process.stderr.write('[azify-logger] register-http-client-early: Module._load hook installed\n') } catch (_) {}
+    }
+  }
+
+  function patchGlobalFetch() {
+    try {
+      if (typeof globalThis.fetch !== 'function') return
+      if (globalThis.fetch.__azifyPatched) return
+      const deps = loadStoreAndSampling()
+      if (!deps || deps.HTTP_CLIENT_MODE === 'off') return
+      const { getRequestContext, getLastJobContext, toTraceIdHex, markSource, HTTP_CLIENT_MODE } = deps
+      const origFetch = globalThis.fetch
+      globalThis.fetch = function (input, init) {
+        const method = (init && init.method) || (input && input.method) || 'GET'
+        const methodStr = String(method).toUpperCase()
+        const urlStr = typeof input === 'string' ? input : (input && (input.url || input.href)) ? String(input.url || input.href) : String(input)
+        httpLog('WRAPPER globalFetch ' + methodStr + ' ' + urlStr.slice(0, 80))
+        const ctx = getRequestContext() || getLastJobContext()
+        const otelCtx = getOtelTraceContext()
+        const traceCtx = ctx || otelCtx
+        const rawTraceId = traceCtx && traceCtx.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
+        const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+        const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method: methodStr, url: urlStr }
+        markSource(requestMeta, 'http-client')
+        const start = require('perf_hooks').performance.now()
+        const skipLog = isLoggerUrl(urlStr)
+        if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${methodStr} ${urlStr}`, requestMeta)
+        return origFetch.apply(this, arguments).then(
+          function (response) {
+            const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog && response) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${response.status} ${duration}ms`, { ...requestMeta, statusCode: response.status, responseTimeMs: duration })
+            return response
+          },
+          function (err) {
+            const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+            throw err
+          }
+        )
+      }
+      globalThis.fetch.__azifyPatched = true
+      if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+        try { process.stderr.write('[azify-logger] register-http-client-early: global fetch patched\n') } catch (_) {}
+      }
+    } catch (_) {}
+  }
+
+  function isUndiciShaped(exports) {
+    if (!exports || typeof exports !== 'object') return false
+    const hasRequest = typeof exports.request === 'function'
+    const hasFetch = typeof exports.fetch === 'function'
+    const hasDispatcher = exports.Dispatcher && typeof exports.Dispatcher.prototype === 'object' && typeof exports.Dispatcher.prototype.request === 'function'
+    return hasRequest || hasFetch || hasDispatcher
+  }
+
+  function getPatchedUndiciSingleton() {
+    return patchedUndiciSingleton
+  }
+
+  function patchUndiciInCache() {
+    try {
+      patchGlobalFetch()
+      const cache = require.cache
+      if (!cache || typeof cache !== 'object') return
+      const singleton = patchedUndiciSingleton
+      let patched = 0
+      let byPath = 0
+      let byShape = 0
+      let apiRequestWrapper = null
+      for (const key of Object.keys(cache)) {
+        if (typeof key !== 'string') continue
+        const p = key.replace(/\\/g, '/')
+        if (p.indexOf('undici') !== -1 && p.indexOf('api-request') !== -1 && p.indexOf('undici-package') === -1) {
+          const mod = cache[key]
+          if (mod && mod.exports && typeof mod.exports === 'function' && mod.exports.__azifyApiRequestPatched) {
+            apiRequestWrapper = mod.exports
+            break
+          }
+        }
+      }
+      for (const key of Object.keys(cache)) {
+        if (typeof key !== 'string') continue
+        const mod = cache[key]
+        if (!mod || !mod.exports) continue
+        const ex = mod.exports
+        const p = key.replace(/\\/g, '/')
+        const pathHasUndici = p.indexOf('undici') !== -1 && !p.includes('undici-package')
+        const shapeMatch = isUndiciShaped(ex)
+        if (!pathHasUndici && !shapeMatch) continue
+        if (pathHasUndici) byPath++
+        if (shapeMatch && !pathHasUndici) byShape++
+        if (apiRequestWrapper && pathHasUndici && p.indexOf('undici/lib/api') !== -1 && (p.endsWith('api/index.js') || p.endsWith('lib/api.js'))) {
+          if (ex && typeof ex.request !== 'undefined' && ex.request !== apiRequestWrapper) {
+            ex.request = apiRequestWrapper
+            httpLog('CACHE_SCAN lib/api.request -> wrapper key=' + String(key).slice(-60))
+          }
+        }
+        const isMainUndici = pathHasUndici && (p.endsWith('undici/index.js') || p.endsWith('undici.js')) && p.indexOf('undici/lib') === -1
+        const beforeRequest = ex && ex.request && ex.request.__azifyPatched
+        const beforeFetch = ex && ex.fetch && ex.fetch.__azifyPatched
+        patchUndiciExports(mod.exports)
+        const afterRequest = ex && ex.request && ex.request.__azifyPatched
+        const afterFetch = ex && ex.fetch && ex.fetch.__azifyPatched
+        if ((afterRequest && !beforeRequest) || (afterFetch && !beforeFetch)) patched++
+        if (isMainUndici && singleton) {
+          if (ex && ex !== singleton && typeof ex.request === 'function' && singleton.request && singleton.request.__azifyPatched) {
+            ex.request = singleton.request
+            httpLog('CACHE_SCAN main undici mutate in place key=' + String(key).slice(-60))
+          }
+          mod.exports = singleton
+          httpLog('CACHE_SCAN main undici -> singleton key=' + String(key).slice(-70))
+        }
+      }
+      httpLog('CACHE_SCAN byPath=' + byPath + ' byShape=' + byShape + ' patched=' + patched)
+      if (HTTP_DEBUG) try {
+        process.stderr.write('[AZIFY] patchUndiciInCache byPath=' + byPath + ' byShape=' + byShape + ' patched=' + patched + '\n')
+        if (byPath > 0 || patched > 0) {
+          process.stderr.write('[AZIFY] undici no cache foi patchado — ao disparar job, espere [AZIFY-PATCH] e REQUEST/RESPONSE enqueued\n')
+        }
+      } catch (_) {}
+      patchGlobalDispatcherInPlace()
+    } catch (_) {}
+  }
+
+  patchGlobalFetch()
+  module.exports = { patchUndiciExports, patchUndiciInCache, patchGlobalFetch, patchGlobalDispatcherInPlace, flushEarlyLogQueue, getPatchedUndiciSingleton }
+} catch (_) {
+  module.exports = { patchUndiciExports: function () {}, patchUndiciInCache: function () {}, patchGlobalFetch: function () {}, patchGlobalDispatcherInPlace: function () {}, flushEarlyLogQueue: function () {}, getPatchedUndiciSingleton: function () { return null } }
+}