azify-logger 1.0.44 → 1.0.45

package/register.js

@@ -1,7 +1,15 @@
 if (process.env.AZIFY_LOGGER_DISABLE === '1') {
   module.exports = {}
 } else {
+if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+  try { process.stderr.write('[azify-logger] REGISTER_START register.js loading\n') } catch (_) {}
+}
 try {
+  if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+    try { process.stderr.write('[azify-logger] REGISTER step1 top try\n') } catch (_) {}
+  }
+  const ModuleForRequire = require('module')
+  const nodeRequireOriginal = ModuleForRequire.prototype.require
   const bunyan = require('bunyan')
   const createBunyanStream = require('./streams/bunyan')
   const { createHttpLoggerTransport } = require('./streams/httpQueue')
@@ -13,6 +21,10 @@ try {
 
   const { shouldSample, markSource, HTTP_CLIENT_MODE } = require('./sampling')
 
+  if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+    try { process.stderr.write('[azify-logger] REGISTER step1b after requires\n') } catch (_) {}
+    try { process.stderr.write('[azify-logger] REGISTER step2-early (right after step1b)\n') } catch (_) {}
+  }
   const serviceName = process.env.APP_NAME
   const environment = process.env.NODE_ENV
   const loggerUrlFromEnv = process.env.AZIFY_LOGGER_URL
@@ -25,11 +37,64 @@ try {
   }
 
   const loggerUrlString = loggerEndpoint.toString()
-  const transport = createHttpLoggerTransport(loggerUrlString)
+  let transport = null
+  const MAX_PENDING_OUTBOUND = 2000
+
+  function sendRequestResponseDirectHttp(payload) {
+    try {
+      const body = typeof payload === 'string' ? payload : JSON.stringify(payload)
+      const isHttps = loggerEndpoint.protocol === 'https:'
+      const lib = isHttps ? require('https') : require('http')
+      const path = (loggerEndpoint.pathname && loggerEndpoint.pathname !== '/') ? loggerEndpoint.pathname : '/log'
+      const port = loggerEndpoint.port ? parseInt(loggerEndpoint.port, 10) : (isHttps ? 443 : 80)
+      const opts = {
+        hostname: loggerEndpoint.hostname,
+        port: Number.isFinite(port) ? port : (isHttps ? 443 : 80),
+        path,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body, 'utf8') }
+      }
+      const debug = process.env.AZIFY_LOGGER_DEBUG === '1'
+      const req = lib.request(opts, function (res) {
+        res.resume()
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          try {
+            process.stderr.write(`[azify-logger] REQUEST/RESPONSE log POST failed: server responded ${res.statusCode} (check log server at ${loggerUrlString})\n`)
+          } catch (_) {}
+          if (debug) try { process.stderr.write(`[azify-logger] direct HTTP log server responded ${res.statusCode}\n`) } catch (_) {}
+        }
+      })
+      req.on('error', function (err) {
+        try {
+          process.stderr.write(`[azify-logger] REQUEST/RESPONSE log POST failed: ${err && err.message} (is log server running at ${loggerUrlString}?)\n`)
+        } catch (_) {}
+        if (debug) try { process.stderr.write(`[azify-logger] direct HTTP to log server failed: ${err && err.message}\n`) } catch (_) {}
+      })
+      req.setTimeout(5000, function () { req.destroy() })
+      req.write(body)
+      req.end()
+    } catch (e) {
+      if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write(`[azify-logger] sendRequestResponseDirectHttp error: ${e && e.message}\n`) } catch (_) {}
+    }
+  }
+  const pendingOutboundLogs = []
+  const flushTransport = () => transport && typeof transport.flush === 'function' ? transport.flush().catch(() => {}) : Promise.resolve()
+  function setTransport(t) {
+    transport = t
+    if (t && pendingOutboundLogs.length > 0) {
+      const toFlush = pendingOutboundLogs.splice(0, pendingOutboundLogs.length)
+      toFlush.forEach(function (item) {
+        try {
+          if (typeof transport.enqueue === 'function') transport.enqueue(item.payload, item.headers || { 'content-type': 'application/json' })
+        } catch (_) {}
+      })
+    }
+    if (t) { process.once('beforeExit', flushTransport); process.once('exit', flushTransport) }
+  }
 
-  const flushTransport = () => transport.flush().catch(() => {})
-  process.once('beforeExit', flushTransport)
-  process.once('exit', flushTransport)
+  try {
+    setTransport(createHttpLoggerTransport(loggerUrlString, {}))
+  } catch (_) {}
 
   const normalizedLoggerOrigin = `${loggerEndpoint.protocol}//${loggerEndpoint.host}`
   const normalizedLoggerPath = normalizePath(loggerEndpoint.pathname || '/')
@@ -78,20 +143,38 @@ try {
     return sanitized
   }
 
+  const debug = process.env.AZIFY_LOGGER_DEBUG === '1'
+  const httpVerbose = process.env.AZIFY_LOGGER_HTTP_VERBOSE === '1'
   function sendOutboundLog(level, message, meta) {
     try {
+      const msgStr = String(message)
+      const isReqRes = msgStr.includes('[REQUEST]') || msgStr.includes('[RESPONSE]')
+      if (isReqRes && meta && meta.url && isLoggerApiCall({ url: meta.url })) return
+      if (isReqRes && meta && (meta.url === 'unknown' || !String(meta.url || '').trim() || String(meta.url).toLowerCase() === 'unknown')) return
       const source = meta && meta.__source
+      if (debug && source === 'pino-stdout') {
+        if (debug) try { process.stderr.write('[azify-logger] SENDOUTBOUND_ENTER level=' + level + ' source=' + source + ' msg=' + msgStr.slice(0, 60) + '\n') } catch (_) {}
+      }
       if (!shouldSample(level, source)) {
+        if (debug && (isReqRes || msgStr.includes('failed after'))) {
+          if (debug) process.stderr.write('[azify-logger] SENDOUTBOUND_SKIP shouldSample level=' + level + ' source=' + source + '\n')
+        }
         return
       }
+      if (debug && source === 'pino-stdout') {
+        if (debug) try { process.stderr.write('[azify-logger] SENDOUTBOUND_ENQUEUE level=' + level + ' msg=' + msgStr.slice(0, 50) + '\n') } catch (_) {}
+      }
 
+      const forceHttpClientSource = source === 'http-client' || isReqRes
+      const effectiveServiceName = serviceName || process.env.APP_NAME || process.env.SERVICE_NAME || (meta && meta.service && meta.service.name) || 'unknown-app'
       const payload = {
         level,
         message,
         meta: {
           ...meta,
+          ...(forceHttpClientSource && { source: 'http-client' }),
           service: {
-            name: serviceName,
+            name: effectiveServiceName,
             version: (meta && meta.service && meta.service.version) || '1.0.0'
           },
           environment,
@@ -99,15 +182,156 @@ try {
           hostname: os.hostname()
         }
       }
+      const headers = { 'content-type': 'application/json' }
+
+      if (isReqRes && loggerUrlString) {
+        if (debug) try { process.stderr.write(`[AZIFY] REQUEST/RESPONSE -> direct HTTP source=${source || 'n/a'} ${msgStr.slice(0, 72)}\n`) } catch (_) {}
+        setImmediate(function () { sendRequestResponseDirectHttp(payload) })
+        return
+      }
 
       if (transport && typeof transport.enqueue === 'function') {
-        transport.enqueue(payload, {
-          'content-type': 'application/json'
-        })
+        transport.enqueue(payload, headers)
+      } else {
+        if (pendingOutboundLogs.length >= MAX_PENDING_OUTBOUND) pendingOutboundLogs.shift()
+        pendingOutboundLogs.push({ payload, headers })
+        if (isReqRes && debug) {
+          try { process.stderr.write(`[AZIFY] REQUEST/RESPONSE PENDING (no transport yet) source=${source || 'n/a'} ${msgStr.slice(0, 60)}\n`) } catch (_) {}
+        }
       }
     } catch (err) {
+      if (debug) process.stderr.write(`[azify-logger] sendOutboundLog error: ${err && err.message}\n`)
     }
   }
+  if (typeof global !== 'undefined') global.__AZIFY_SEND_OUTBOUND_LOG = sendOutboundLog
+  try {
+    const early = require('./register-http-client-early')
+    if (typeof early.flushEarlyLogQueue === 'function') early.flushEarlyLogQueue()
+    if (typeof early.patchUndiciInCache === 'function') early.patchUndiciInCache()
+  } catch (_) {}
+
+  const MAX_LINE_BUFFER_BYTES = 2 * 1024 * 1024
+  function makePinoCaptureHandler(streamName) {
+    let inCapture = false
+    let lineBuffer = ''
+    function trySendLine(line) {
+      const trimmed = line.trim()
+      if (debug && trimmed.startsWith('{') && (trimmed.includes('"msg":') || trimmed.includes('"message":'))) {
+        if (debug) try { process.stderr.write('[azify-logger] TRYSENDLINE_IN stream=' + streamName + ' len=' + trimmed.length + ' preview=' + trimmed.slice(0, 80) + '...\n') } catch (_) {}
+      }
+      if (!trimmed.startsWith('{') || (!trimmed.includes('"msg":') && !trimmed.includes('"message":'))) {
+        if (debug && trimmed.length > 0 && trimmed.length < 200) {
+          if (debug) try { process.stderr.write('[azify-logger] TRYSENDLINE_SKIP no json/msg stream=' + streamName + ' preview=' + trimmed.slice(0, 60) + '\n') } catch (_) {}
+        }
+        return
+      }
+      try {
+        const record = JSON.parse(trimmed)
+        const msg = record.msg || record.message || ''
+        if (!msg || typeof record.level !== 'number') {
+          if (debug) try { process.stderr.write(`[azify-logger] TRYSENDLINE_SKIP no level/msg stream=${streamName}\n`) } catch (_) {}
+          return
+        }
+        inCapture = true
+        const levelMap = { 60: 'fatal', 50: 'error', 40: 'warn', 30: 'info', 20: 'debug', 10: 'trace' }
+        const level = levelMap[record.level] || 'info'
+        const { getRequestContext, getLastJobContext, toTraceIdHex } = require('./store')
+        let ctx = getRequestContext()
+        if (!ctx || !ctx.traceId) ctx = getLastJobContext()
+        let traceId = (ctx && ctx.traceId) ? toTraceIdHex(String(ctx.traceId)) : null
+        let spanId = ctx && ctx.spanId != null ? String(ctx.spanId).slice(0, 16) : null
+        if (!traceId && typeof msg === 'string' && /traceId/i.test(msg)) {
+          const m = msg.match(/"traceId"\s*:\s*"([^"]+)"/)
+          if (m) traceId = toTraceIdHex(m[1])
+        }
+        if (!traceId) {
+          try {
+            const { startRequestContext } = require('./store')
+            const c = startRequestContext({})
+            traceId = c.traceId
+            spanId = c.spanId
+          } catch (_) {
+            traceId = require('crypto').randomUUID ? require('crypto').randomUUID().replace(/-/g, '') : String(Date.now())
+          }
+        }
+        const meta = { traceId, spanId, parentSpanId: ctx && ctx.parentSpanId, requestId: ctx && ctx.requestId, __source: 'pino-stdout' }
+        if (debug) try { process.stderr.write(`[azify-logger] TRYSENDLINE_SEND level=${level} msg=${String(msg).slice(0, 50)}\n`) } catch (_) {}
+        sendOutboundLog(level, msg, meta)
+        if (debug) process.stderr.write(`[azify-logger] TRYSENDLINE_DONE ${streamName} sent: ${String(msg).slice(0, 60)}\n`)
+      } catch (e) {
+        if (debug) try { process.stderr.write(`[azify-logger] TRYSENDLINE_ERR stream=${streamName} ${e && e.message}\n`) } catch (_) {}
+      } finally {
+        inCapture = false
+      }
+    }
+    return function handleChunk(str) {
+      if (typeof str !== 'string' || !str || inCapture) return
+      if (debug && str.trim().startsWith('{') && (str.includes('"level":') || str.includes('"msg":'))) {
+        if (debug) try { process.stderr.write('[azify-logger] CAPTURE_CHUNK stream=' + streamName + ' len=' + str.length + ' preview=' + str.slice(0, 70).replace(/\n/g, ' ') + '...\n') } catch (_) {}
+      }
+      lineBuffer += str
+      if (lineBuffer.length > MAX_LINE_BUFFER_BYTES) {
+        const lastNewline = lineBuffer.lastIndexOf('\n')
+        if (lastNewline > 0) {
+          const keep = lineBuffer.slice(lastNewline + 1)
+          lineBuffer = lineBuffer.slice(0, lastNewline + 1)
+          const lines = lineBuffer.split('\n')
+          lineBuffer = lines.pop() || ''
+          for (let i = 0; i < lines.length; i++) trySendLine(lines[i])
+          lineBuffer = keep
+        } else {
+          lineBuffer = lineBuffer.slice(-1024)
+        }
+      }
+      const lines = lineBuffer.split('\n')
+      lineBuffer = lines.pop() || ''
+      for (let i = 0; i < lines.length; i++) trySendLine(lines[i])
+      if (lineBuffer.trim().startsWith('{') && lineBuffer.trim().endsWith('}')) {
+        trySendLine(lineBuffer)
+        lineBuffer = ''
+      }
+    }
+  }
+  const stdoutCapture = makePinoCaptureHandler('stdout')
+  const stderrCapture = makePinoCaptureHandler('stderr')
+
+  function patchStreamAtWrite(stream, streamName, capture) {
+    if (!stream || stream.__azifyLoggerWritePatched) return
+    const origWrite = stream.write
+    if (typeof origWrite !== 'function') return
+    stream.write = function(chunk, encoding, callback) {
+      const str = (typeof chunk === 'string' ? chunk : (chunk && chunk.toString ? chunk.toString() : ''))
+      capture(str)
+      return origWrite.apply(this, arguments)
+    }
+    stream.__azifyLoggerWritePatched = true
+  }
+
+  function patchStreamAt_Writer(stream, streamName, capture) {
+    if (!stream || !stream._write || stream.__azifyLogger_WriterPatched) return
+    const orig_Writer = stream._write.bind(stream)
+    stream._write = function(chunk, encoding, callback) {
+      const str = (typeof chunk === 'string' ? chunk : (chunk && chunk.toString ? chunk.toString() : ''))
+      capture(str)
+      return orig_Writer(chunk, encoding, callback)
+    }
+    stream.__azifyLogger_WriterPatched = true
+  }
+
+  try {
+    if (!global.__AZIFY_LOGGER_STDOUT_PATCHED) {
+      global.__AZIFY_LOGGER_STDOUT_PATCHED = true
+      patchStreamAtWrite(process.stdout, 'stdout', stdoutCapture)
+      patchStreamAt_Writer(process.stdout, 'stdout', stdoutCapture)
+    }
+  } catch (_) {}
+  try {
+    if (!global.__AZIFY_LOGGER_STDERR_PATCHED) {
+      global.__AZIFY_LOGGER_STDERR_PATCHED = true
+      patchStreamAtWrite(process.stderr, 'stderr', stderrCapture)
+      patchStreamAt_Writer(process.stderr, 'stderr', stderrCapture)
+    }
+  } catch (_) {}
 
   function normalizePath(path) {
     if (!path) {
@@ -162,12 +386,12 @@ try {
       const otelApi = require('@opentelemetry/api')
       const activeContext = otelApi.context.active()
       const span = otelApi.trace.getSpan(activeContext)
-      
+
       if (!span) return null
-      
+
       const spanContext = span.spanContext()
       if (!spanContext || !spanContext.traceId) return null
-      
+
       return {
         traceId: spanContext.traceId,
         spanId: spanContext.spanId,
@@ -178,32 +402,181 @@ try {
     }
   }
 
+  const Module = require('module')
+  const originalRequireForEarly = Module.prototype.require
+  function patchUndiciExportsEarly(exports) {
+    if (!exports || typeof exports.request !== 'function' || exports.request.__azifyPatched) return exports
+    const { randomBytes } = require('crypto')
+    const { performance } = require('perf_hooks')
+    const { getRequestContext, getLastJobContext, toTraceIdHex } = require('./store')
+    const origRequest = exports.request
+    exports.request = function(url, options, callback) {
+      const ctx = getRequestContext() || getLastJobContext()
+      const otelCtx = getOtelTraceContext()
+      const traceCtx = ctx || otelCtx
+      const method = (options?.method || 'GET').toUpperCase()
+      const urlString = typeof url === 'string' ? url : (url && url.toString && url.toString()) || 'unknown'
+      const rawTraceId = traceCtx?.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
+      const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+      const requestMeta = { traceId, spanId: traceCtx?.spanId || null, parentSpanId: traceCtx?.parentSpanId || null, requestId: traceCtx?.requestId || null, method, url: urlString }
+      markSource(requestMeta, 'http-client')
+      const startTime = performance.now()
+      if (HTTP_CLIENT_MODE !== 'off') {
+        sendOutboundLog('info', `[REQUEST] ${method} ${urlString}`, requestMeta)
+      }
+      const wrappedCb = callback ? function(err, data) {
+        const duration = Number((performance.now() - startTime).toFixed(2))
+        if (HTTP_CLIENT_MODE !== 'off') {
+          if (err) sendOutboundLog('error', `[RESPONSE] ${method} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+          else if (data) sendOutboundLog('info', `[RESPONSE] ${method} ${urlString} ${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 promise = origRequest.call(this, url, options)
+      if (promise && typeof promise.then === 'function') {
+        return promise.then(
+          (data) => {
+            const duration = Number((performance.now() - startTime).toFixed(2))
+            if (HTTP_CLIENT_MODE !== 'off' && data) {
+              sendOutboundLog('info', `[RESPONSE] ${method} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+            }
+            return data
+          },
+          (err) => {
+            const duration = Number((performance.now() - startTime).toFixed(2))
+            if (HTTP_CLIENT_MODE !== 'off') {
+              sendOutboundLog('error', `[RESPONSE] ${method} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: (err && err.message) || String(err), responseTimeMs: duration })
+            }
+            throw err
+          }
+        )
+      }
+      return promise
+    }
+    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 origDispRequest = proto.request
+      proto.request = function(opts, callback) {
+        const ctx = getRequestContext() || getLastJobContext()
+        const otelCtx = getOtelTraceContext()
+        const traceCtx = ctx || otelCtx
+        const methodStr = String((opts && opts.method) || 'GET').toUpperCase()
+        const origin = (opts && opts.origin) || ''
+        const path = (opts && opts.path) != null ? opts.path : '/'
+        const urlString = origin ? (origin + (path.startsWith('/') ? path : '/' + path)) : 'unknown'
+        const rawTraceId = traceCtx?.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
+        const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+        const requestMeta = { traceId, spanId: traceCtx?.spanId || null, parentSpanId: traceCtx?.parentSpanId || null, requestId: traceCtx?.requestId || null, method: methodStr, url: urlString }
+        markSource(requestMeta, 'http-client')
+        const startTime = performance.now()
+        if (HTTP_CLIENT_MODE !== 'off') {
+          sendOutboundLog('info', `[REQUEST] ${methodStr} ${urlString}`, requestMeta)
+        }
+        const wrappedCb = typeof callback === 'function' ? function(err, data) {
+          const duration = Number((performance.now() - startTime).toFixed(2))
+          if (HTTP_CLIENT_MODE !== 'off') {
+            if (err) sendOutboundLog('error', `[RESPONSE] ${methodStr} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+            else if (data) sendOutboundLog('info', `[RESPONSE] ${methodStr} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+          }
+          return callback(err, data)
+        } : undefined
+        const ret = wrappedCb ? origDispRequest.call(this, opts, wrappedCb) : origDispRequest.call(this, opts)
+        if (ret && typeof ret.then === 'function' && !wrappedCb) {
+          return ret.then(
+            (data) => {
+              const duration = Number((performance.now() - startTime).toFixed(2))
+              if (HTTP_CLIENT_MODE !== 'off' && data) {
+                sendOutboundLog('info', `[RESPONSE] ${methodStr} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+              }
+              return data
+            },
+            (err) => {
+              const duration = Number((performance.now() - startTime).toFixed(2))
+              if (HTTP_CLIENT_MODE !== 'off') {
+                sendOutboundLog('error', `[RESPONSE] ${methodStr} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: (err && err.message) || String(err), responseTimeMs: duration })
+              }
+              throw err
+            }
+          )
+        }
+        return ret
+      }
+      proto.request.__azifyPatched = true
+    }
+    return exports
+  }
+  try {
+    const origLoad = Module._load
+    if (origLoad && origLoad.__azifyEarlyPatched) {
+      if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] Module._load keeping early hook (not overwriting)\n') } catch (_) {}
+    } else if (typeof origLoad === 'function' && !Module._load.__azifyPatched) {
+      Module._load = function (request, parent, isMain) {
+        const result = origLoad.apply(this, arguments)
+        const pathStr = typeof request === 'string' ? request.replace(/\\/g, '/') : ''
+        const isUndici = pathStr === 'undici' || (pathStr.indexOf('undici') !== -1 && pathStr.indexOf('undici-package') === -1)
+        if (isUndici) {
+          if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write(`[azify-logger] Module._load UNDICI path=${pathStr.slice(-90)}\n`) } catch (_) {}
+          try {
+            patchUndiciExportsEarly(result)
+          } catch (e) {
+            if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] Module._load patchUndiciExportsEarly threw: ' + (e && e.message) + '\n') } catch (_) {}
+          }
+        }
+        return result
+      }
+      Module._load.__azifyPatched = true
+      if (debug) try { process.stderr.write('[azify-logger] Module._load hook installed (early)\n') } catch (_) {}
+    }
+  } catch (_) {}
+
+  if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+    try { process.stderr.write('[azify-logger] REGISTER step2 before first hook\n') } catch (_) {}
+  }
   try {
-    const Module = require('module')
     const originalRequire = Module.prototype.require
     const { getRequestContext } = require('./store')
-    
+
     Module.prototype.require = function(id) {
       const result = originalRequire.call(this, id)
+      const idStr = typeof id === 'string' ? id : ''
+      const idLooksLikeUndici = idStr === 'undici' || (idStr.length > 0 && idStr.replace(/\\/g, '/').indexOf('undici') !== -1 && idStr.indexOf('undici-package') === -1)
+      const looksLikeUndici = result && (typeof result.request === 'function' || typeof result.fetch === 'function') && (result.request && !result.request.__azifyPatched || result.fetch && !result.fetch.__azifyPatched)
+      if (process.env.AZIFY_LOGGER_DEBUG === '1' && (idLooksLikeUndici || looksLikeUndici)) {
+        try { process.stderr.write('[azify-logger] require undici-like id=' + idStr.slice(-70) + ' hasRequest=' + !!(result && result.request) + ' hasFetch=' + !!(result && result.fetch) + '\n') } catch (_) {}
+      }
+      if (debug && (idLooksLikeUndici || id === 'nestjs-pino')) {
+        try { process.stderr.write('[azify-logger] require hook id=' + id + '\n') } catch (_) {}
+      }
+      if ((idLooksLikeUndici || looksLikeUndici) && result) {
+        if (process.env.AZIFY_LOGGER_HTTP_DEBUG === '1' || process.env.AZIFY_LOGGER_DEBUG === '1') {
+          try { process.stderr.write('[AZIFY-HTTP] REGISTER_HOOK1 patch id=' + idStr.slice(-70) + '\n') } catch (_) {}
+        }
+        try {
+          const early = require('./register-http-client-early')
+          if (typeof early.patchUndiciExports === 'function') early.patchUndiciExports(result)
+        } catch (_) {}
+      }
       if (id === 'pino' || id.endsWith('/pino')) {
         if (result && typeof result === 'function') {
           const originalPino = result
-          
+
           const patchedPino = function(options, stream) {
             if (new.target) {
               return originalPino.call(this, options, stream)
             }
-            
+
             const logger = originalPino(options, stream)
             return applyLoggerPatches(logger, options)
           }
-          
+
           function applyLoggerPatches(logger, pinoOptions) {
             if (logger.__azifyPatched) {
               return logger
             }
             logger.__azifyPatched = true
-            
+
             const originalLog = logger.log
             const originalInfo = logger.info
             const originalError = logger.error
@@ -212,13 +585,13 @@ try {
             const originalFatal = logger.fatal
             const originalTrace = logger.trace
             const originalChild = logger.child
-            
+
             const patchLogMethod = (original, methodName) => {
               return function(obj, msg, ...args) {
                 const otelCtx = getOtelTraceContext()
                 const ctx = getRequestContext()
-                const traceCtx = otelCtx || ctx
-                
+                const traceCtx = ctx || otelCtx
+
                 if (traceCtx && traceCtx.traceId) {
                   if (typeof obj === 'object' && obj !== null) {
                     obj = {
@@ -229,20 +602,20 @@ try {
                       requestId: traceCtx.requestId || ctx?.requestId
                     }
                   } else {
-                    obj = { 
-                      traceId: traceCtx.traceId, 
-                      spanId: traceCtx.spanId, 
-                      parentSpanId: traceCtx.parentSpanId, 
-                      requestId: traceCtx.requestId || ctx?.requestId, 
-                      msg: obj 
+                    obj = {
+                      traceId: traceCtx.traceId,
+                      spanId: traceCtx.spanId,
+                      parentSpanId: traceCtx.parentSpanId,
+                      requestId: traceCtx.requestId || ctx?.requestId,
+                      msg: obj
                     }
                   }
-                  
+
                   try {
                     const levelMap = { log: 'info', info: 'info', error: 'error', warn: 'warn', debug: 'debug', fatal: 'fatal', trace: 'trace' }
                     const level = levelMap[methodName] || 'info'
                     const message = (typeof obj === 'object' ? obj.message : obj) || msg || ''
-                    
+
                     const meta = {
                       ...obj,
                       service: {
@@ -253,15 +626,15 @@ try {
                       timestamp: new Date().toISOString(),
                       hostname: require('os').hostname()
                     }
-                    
+
                     sendOutboundLog(level, message, meta)
                   } catch (err) {}
                 }
-                
+
                 return original.call(this, obj, msg, ...args)
               }
             }
-            
+
             logger.log = patchLogMethod(originalLog, 'log')
             logger.info = patchLogMethod(originalInfo, 'info')
             logger.error = patchLogMethod(originalError, 'error')
@@ -269,97 +642,130 @@ try {
             logger.debug = patchLogMethod(originalDebug, 'debug')
             logger.fatal = patchLogMethod(originalFatal, 'fatal')
             logger.trace = patchLogMethod(originalTrace, 'trace')
-            
+
             logger.child = function(bindings, options) {
               const childLogger = originalChild.call(this, bindings, options)
               return applyLoggerPatches(childLogger, pinoOptions)
             }
-            
+
             return logger
           }
-          
+
           Object.setPrototypeOf(patchedPino, originalPino)
           Object.assign(patchedPino, originalPino)
-          
+
           return patchedPino
         }
       }
-      
+
       return result
     }
-    
+
   } catch (_) {}
 
-  try {
-    const { Logger } = require('@nestjs/common')
-    if (Logger) {
-      const originalLog = Logger.prototype.log
-      const originalError = Logger.prototype.error
-      const originalWarn = Logger.prototype.warn
-      const originalDebug = Logger.prototype.debug
-      const originalVerbose = Logger.prototype.verbose
-      
-      Logger.prototype.log = function(message, context) {
-        const { getRequestContext } = require('./store')
-        const ctx = getRequestContext()
-        if (ctx && ctx.traceId) {
-          return originalLog.call(this, message, context)
-        }
-        return originalLog.call(this, message, context)
+  function patchNestLogger(Logger) {
+    if (!Logger || !Logger.prototype || Logger.prototype.__azifyNestLoggerPatched) return
+    const { getRequestContext, getLastJobContext, toTraceIdHex } = require('./store')
+    Logger.prototype.__azifyNestLoggerPatched = true
+    const originalLog = Logger.prototype.log
+    const originalError = Logger.prototype.error
+    const originalWarn = Logger.prototype.warn
+    const originalDebug = Logger.prototype.debug
+    const originalVerbose = Logger.prototype.verbose
+
+    function nestLoggerMeta(message) {
+      let ctx = getRequestContext()
+      if (!ctx || !ctx.traceId) {
+        const jobCtx = getLastJobContext()
+        if (jobCtx && jobCtx.traceId) ctx = jobCtx
       }
-      
-      Logger.prototype.error = function(message, trace, context) {
-        const { getRequestContext } = require('./store')
-        const ctx = getRequestContext()
-        if (ctx && ctx.traceId) {
-          return originalError.call(this, message, trace, context)
-        }
-        return originalError.call(this, message, trace, context)
-      }
-      
-      Logger.prototype.warn = function(message, context) {
-        const { getRequestContext } = require('./store')
-        const ctx = getRequestContext()
-        if (ctx && ctx.traceId) {
-          return originalWarn.call(this, message, context)
-        }
-        return originalWarn.call(this, message, context)
-      }
-      
-      Logger.prototype.debug = function(message, context) {
-        const { getRequestContext } = require('./store')
-        const ctx = getRequestContext()
-        if (ctx && ctx.traceId) {
-          return originalDebug.call(this, message, context)
+      if (!ctx || !ctx.traceId) {
+        try {
+          const { startRequestContext } = require('./store')
+          ctx = startRequestContext({})
+        } catch (_) {
+          ctx = { traceId: require('crypto').randomUUID ? require('crypto').randomUUID().replace(/-/g, '') : String(Date.now()), spanId: null, parentSpanId: null, requestId: null }
         }
-        return originalDebug.call(this, message, context)
       }
-      
-      Logger.prototype.verbose = function(message, context) {
-        const { getRequestContext } = require('./store')
-        const ctx = getRequestContext()
-        if (ctx && ctx.traceId) {
-          return originalVerbose.call(this, message, context)
-        }
-        return originalVerbose.call(this, message, context)
+      const traceId = ctx.traceId ? toTraceIdHex(String(ctx.traceId)) : null
+      const msg = typeof message === 'string' ? message : (message && message.message) || (message && message.msg) || String(message)
+      return {
+        traceId,
+        spanId: ctx.spanId != null ? String(ctx.spanId).slice(0, 16) : null,
+        parentSpanId: ctx.parentSpanId ?? null,
+        requestId: ctx.requestId ?? null,
+        message: msg
       }
-      
     }
+
+    function skipUndefinedMessage(msg) {
+      return msg == null || (typeof msg === 'string' && msg.trim() === '')
+    }
+
+    Logger.prototype.log = function(message, context) {
+      if (skipUndefinedMessage(message)) return
+      try {
+        const meta = nestLoggerMeta(message)
+        if (meta.traceId) sendOutboundLog('info', meta.message || message, meta)
+      } catch (_) {}
+      return originalLog.call(this, message, context)
+    }
+
+    Logger.prototype.error = function(message, trace, context) {
+      if (skipUndefinedMessage(message)) return
+      try {
+        const meta = nestLoggerMeta(message)
+        if (meta.traceId) sendOutboundLog('error', meta.message || message, meta)
+      } catch (_) {}
+      return originalError.call(this, message, trace, context)
+    }
+
+    Logger.prototype.warn = function(message, context) {
+      if (skipUndefinedMessage(message)) return
+      try {
+        const meta = nestLoggerMeta(message)
+        if (meta.traceId) sendOutboundLog('warn', meta.message || message, meta)
+      } catch (_) {}
+      return originalWarn.call(this, message, context)
+    }
+
+    Logger.prototype.debug = function(message, context) {
+      if (skipUndefinedMessage(message)) return
+      try {
+        const meta = nestLoggerMeta(message)
+        if (meta.traceId) sendOutboundLog('debug', meta.message || message, meta)
+      } catch (_) {}
+      return originalDebug.call(this, message, context)
+    }
+
+    Logger.prototype.verbose = function(message, context) {
+      if (skipUndefinedMessage(message)) return
+      try {
+        const meta = nestLoggerMeta(message)
+        if (meta.traceId) sendOutboundLog('debug', meta.message || message, meta)
+      } catch (_) {}
+      return originalVerbose.call(this, message, context)
+    }
+  }
+
+  try {
+    const { Logger } = require('@nestjs/common')
+    patchNestLogger(Logger)
   } catch (_) {}
 
   try {
     const originalConsoleLog = console.log
     const originalConsoleError = console.error
     const originalConsoleWarn = console.warn
-    
+
     console.log = function(...args) {
       return originalConsoleLog.apply(this, args)
     }
-    
+
     console.error = function(...args) {
       return originalConsoleError.apply(this, args)
     }
-    
+
     console.warn = function(...args) {
       return originalConsoleWarn.apply(this, args)
     }
@@ -368,54 +774,142 @@ try {
   try {
     const Module = require('module')
     const originalRequire = Module.prototype.require
-    
-    Module.prototype.require = function(id) {
-      const result = originalRequire.call(this, id)
-      
-      if (id === 'nestjs-pino' || id.endsWith('/nestjs-pino') || id.includes('nestjs-pino')) {
-        if (result && result.Logger && result.Logger.prototype) {
-          const proto = result.Logger.prototype
-          const originalCall = proto.call
-          
-          proto.call = function(callMethod, message, context) {
-            const { getRequestContext } = require('./store')
-            const ctx = getRequestContext()
-            
-            if (ctx && ctx.traceId) {
-              if (typeof message === 'object' && message !== null) {
-                message = {
-                  ...message,
-                  traceId: ctx.traceId,
-                  spanId: ctx.spanId,
-                  parentSpanId: ctx.parentSpanId,
-                  requestId: ctx.requestId
-                }
-              }
-              
+    function isAzifyLoggerInternal(id) {
+      if (typeof id !== 'string') return false
+      const n = id.replace(/\\/g, '/')
+      if (n === './store' || n === 'store' || n.endsWith('/store') || n.endsWith('/store.js')) return true
+      if (n === './middleware-express' || n === 'middleware-express' || n.includes('middleware-express')) return true
+      if (n === './streams/httpQueue' || n.includes('httpQueue')) return true
+      return false
+    }
+    function callerIsAzifyLogger() {
+      try {
+        const fn = (this && this.filename) ? this.filename : (this && this.id) ? this.id : ''
+        return typeof fn === 'string' && fn.replace(/\\/g, '/').includes('azify-logger')
+      } catch (_) { return false }
+    }
+
+    const bypassRequire = (typeof global.__AZIFY_NODE_REQUIRE === 'function') ? global.__AZIFY_NODE_REQUIRE : nodeRequireOriginal
+    const patchableIds = ['undici', 'pino', 'bull', 'bullmq', 'nestjs-pino', '@nestjs/common']
+    function applyPatchesToModule(result, id) {
+      const pathNorm = typeof id === 'string' ? id.replace(/\\/g, '/') : ''
+      const is = (name) => id === name || pathNorm.includes(name)
+      if (is('@nestjs/common')) {
+        try {
+          if (result && result.Logger) patchNestLogger(result.Logger)
+        } catch (_) {}
+      }
+      if (is('nestjs-pino')) {
+        function patchPinoLoggerClass(LoggerClass) {
+          if (!LoggerClass || !LoggerClass.prototype || LoggerClass.prototype.__azifyPinoLoggerPatched) return
+          if (debug) process.stderr.write('[azify-logger] patching nestjs-pino Logger\n')
+          LoggerClass.prototype.__azifyPinoLoggerPatched = true
+          const { getRequestContext, getLastJobContext, toTraceIdHex } = require('./store')
+          const proto = LoggerClass.prototype
+
+          function pinoLoggerCtx(message) {
+            let ctx = getRequestContext()
+            const jobCtx = getLastJobContext()
+            if ((!ctx || !ctx.traceId) && jobCtx && jobCtx.traceId) ctx = jobCtx
+            const fromPayload = typeof message === 'object' && message !== null && (message.traceId || (message && message.data && message.data.traceId))
+            let traceId = fromPayload ? (message.traceId || (message.data && message.data.traceId)) : (ctx && ctx.traceId)
+            let spanId = fromPayload ? (message.spanId || (message.data && message.data.spanId)) : (ctx && ctx.spanId)
+            if (!traceId && typeof message === 'string' && /traceId/i.test(message)) {
+              const m = message.match(/"traceId"\s*:\s*"([^"]+)"/)
+              if (m) { traceId = m[1]; const s = message.match(/"spanId"\s*:\s*"([^"]+)"/); spanId = s ? s[1] : null }
+            }
+            let effectiveCtx = traceId ? { traceId: toTraceIdHex(String(traceId)), spanId: spanId != null ? String(spanId).slice(0, 16) : null, parentSpanId: (fromPayload && message && (message.parentSpanId != null || (message.data && message.data.parentSpanId != null)) ? (message.parentSpanId || (message.data && message.data.parentSpanId)) : ctx?.parentSpanId) ?? null, requestId: (fromPayload && message && (message.requestId != null || (message.data && message.data.requestId != null)) ? (message.requestId || (message.data && message.data.requestId)) : ctx?.requestId) ?? null } : ctx
+            if (!effectiveCtx || !effectiveCtx.traceId) {
               try {
-                const levelMap = { log: 'info', info: 'info', error: 'error', warn: 'warn', debug: 'debug', fatal: 'fatal', trace: 'trace', verbose: 'debug' }
-                const level = levelMap[callMethod] || 'info'
-                const msg = (typeof message === 'object' ? message.message : message) || ''
-                
-                const meta = {
-                  ...(typeof message === 'object' ? message : {}),
-                  traceId: ctx.traceId,
-                  spanId: ctx.spanId,
-                  parentSpanId: ctx.parentSpanId,
-                  requestId: ctx.requestId
-                }
-                
-                sendOutboundLog(level, msg, meta)
-              } catch (err) {}
+                const { startRequestContext } = require('./store')
+                effectiveCtx = startRequestContext({})
+              } catch (_) {
+                effectiveCtx = { traceId: require('crypto').randomUUID ? require('crypto').randomUUID().replace(/-/g, '') : String(Date.now()), spanId: null, parentSpanId: null, requestId: null }
+              }
             }
-            
-            return originalCall.call(this, callMethod, message, context)
+            const msg = (typeof message === 'object' && message !== null ? message.message : message) || ''
+            return { effectiveCtx, msg }
           }
+
+          function pinoLoggerSend(level, message, meta) {
+            try {
+              const msg = (typeof message === 'string' ? message : (meta && meta.msg)) || (typeof message === 'object' && message !== null ? message.message : null) || ''
+              if (!msg && level !== 'debug' && level !== 'trace') return
+              const payload = { traceId: meta.effectiveCtx.traceId, spanId: meta.effectiveCtx.spanId, parentSpanId: meta.effectiveCtx.parentSpanId, requestId: meta.effectiveCtx.requestId, __source: 'pino-stdout', ...(typeof message === 'object' && message !== null ? message : {}) }
+              sendOutboundLog(level, msg, payload)
+              if (debug && (String(msg).includes('failed after') || String(msg).includes('[REQUEST]') || String(msg).includes('[RESPONSE]'))) {
+                process.stderr.write(`[azify-logger] nestjs-pino sent: ${String(msg).slice(0, 70)}\n`)
+              }
+            } catch (_) {}
+          }
+
+          const originalCall = proto.call
+          proto.call = function(callMethod, message, ...optionalParams) {
+            const { effectiveCtx, msg } = pinoLoggerCtx(message)
+            if (typeof message === 'object' && message !== null) {
+              message = { ...message, traceId: effectiveCtx.traceId, spanId: effectiveCtx.spanId, parentSpanId: effectiveCtx.parentSpanId, requestId: effectiveCtx.requestId }
+            }
+            pinoLoggerSend({ log: 'info', info: 'info', error: 'error', warn: 'warn', debug: 'debug', fatal: 'fatal', trace: 'trace', verbose: 'debug' }[callMethod] || 'info', message, { effectiveCtx, msg })
+            return originalCall.apply(this, [callMethod, message, ...optionalParams])
+          }
+
+          const origError = proto.error
+          const origLog = proto.log
+          const origWarn = proto.warn
+          const origDebug = proto.debug
+          const origVerbose = proto.verbose
+          function skipUndefinedMsg(msg) {
+            return msg == null || (typeof msg === 'string' && msg.trim() === '')
+          }
+          if (typeof origError === 'function') {
+            proto.error = function(message, trace, context) {
+              if (skipUndefinedMsg(message)) return
+              const meta = pinoLoggerCtx(message)
+              pinoLoggerSend('error', message, meta)
+              return origError.call(this, message, trace, context)
+            }
+          }
+          if (typeof origLog === 'function') {
+            proto.log = function(message, context) {
+              if (skipUndefinedMsg(message)) return
+              const meta = pinoLoggerCtx(message)
+              pinoLoggerSend('info', message, meta)
+              return origLog.call(this, message, context)
+            }
+          }
+          if (typeof origWarn === 'function') {
+            proto.warn = function(message, context) {
+              if (skipUndefinedMsg(message)) return
+              const meta = pinoLoggerCtx(message)
+              pinoLoggerSend('warn', message, meta)
+              return origWarn.call(this, message, context)
+            }
+          }
+          if (typeof origDebug === 'function') {
+            proto.debug = function(message, context) {
+              if (skipUndefinedMsg(message)) return
+              const meta = pinoLoggerCtx(message)
+              pinoLoggerSend('debug', message, meta)
+              return origDebug.call(this, message, context)
+            }
+          }
+          if (typeof origVerbose === 'function') {
+            proto.verbose = function(message, context) {
+              if (skipUndefinedMsg(message)) return
+              const meta = pinoLoggerCtx(message)
+              pinoLoggerSend('debug', message, meta)
+              return origVerbose.call(this, message, context)
+            }
+          }
+        }
+        if (result && result.Logger) patchPinoLoggerClass(result.Logger)
+        if (result && typeof result === 'function' && result.prototype && (result.prototype.call != null || result.prototype.error != null) && !result.prototype.__azifyPinoLoggerPatched) {
+          patchPinoLoggerClass(result)
         }
-        
+
         if (result && result.LoggerModule && result.LoggerModule.forRoot) {
           const originalForRoot = result.LoggerModule.forRoot
-          
+
           result.LoggerModule.forRoot = function(options) {
             if (process.env.AZIFY_LOGGER_URL) {
               try {
@@ -425,13 +919,13 @@ try {
                   serviceName: process.env.APP_NAME || (options && options.pinoHttp && options.pinoHttp.name),
                   environment: process.env.NODE_ENV
                 })
-                
+
                 const pinoHttp = (options && options.pinoHttp) || {}
-                
+
                 if (pinoHttp.transport) {
                   return originalForRoot.call(this, options)
                 }
-                
+
                 const mergedOptions = {
                   ...options,
                   pinoHttp: {
@@ -439,176 +933,592 @@ try {
                     stream: azifyStream,
                   },
                 }
-                
+
                 return originalForRoot.call(this, mergedOptions)
               } catch (err) {
                 return originalForRoot.call(this, options)
               }
             }
-            
+
             return originalForRoot.call(this, options)
           }
-          
+
           Object.setPrototypeOf(result.LoggerModule.forRoot, originalForRoot)
           Object.assign(result.LoggerModule.forRoot, originalForRoot)
         }
       }
-      
-      return result
-    }
-    
-  } catch (_) {}
 
-  try {
-    const undici = require('undici')
-    if (undici && undici.request) {
-      const originalRequest = undici.request
-      const { randomBytes } = require('crypto')
-      const { performance } = require('perf_hooks')
-      const { shouldSample, markSource, HTTP_CLIENT_MODE } = require('./sampling')
-      
-      undici.request = function(url, options, callback) {
-        const { getRequestContext } = require('./store')
-        const ctx = getRequestContext()
-        const otelCtx = getOtelTraceContext()
-        const traceCtx = otelCtx || ctx
-        
-        const method = (options?.method || 'GET').toUpperCase()
-        const urlString = typeof url === 'string' ? url : url?.toString() || 'unknown'
-        
-        const traceId = traceCtx?.traceId || randomUUID()
-        const parentSpanId = traceCtx?.spanId || null
-        const requestId = traceCtx?.requestId || ctx?.requestId || randomUUID()
-        const spanId = randomBytes(8).toString('hex')
-        
-        const requestMeta = {
-          traceId,
-          spanId,
-          parentSpanId,
-          requestId,
-          method,
-          url: urlString
-        }
-        
-        markSource(requestMeta, 'http-client')
-        
-        const startTime = performance.now()
-        
-        const shouldLogRequest = HTTP_CLIENT_MODE === 'all' || HTTP_CLIENT_MODE === 'errors' || !!traceId
-        if (shouldLogRequest) {
-          sendOutboundLog('info', `[REQUEST] ${method} ${urlString}`, requestMeta)
-        }
-        
-        if (traceCtx && traceCtx.traceId) {
-          const headers = (options && options.headers) || {}
-          options = {
-            ...options,
-            headers: {
-              ...headers,
-              'X-Trace-ID': traceCtx.traceId,
-              'X-Span-ID': spanId,
-              'X-Parent-Span-ID': traceCtx.parentSpanId || '',
-              'X-Request-ID': requestId
+      const skipBullPatch = process.env.AZIFY_LOGGER_NO_BULL_PATCH === '1'
+      if (!skipBullPatch && pathNorm.includes('explorer') && (pathNorm.includes('@nestjs/bull') || pathNorm.includes('nestjs/bull')) && !pathNorm.includes('bullmq')) {
+        try {
+          const Cls = (result && result.BullExplorer) || result
+          if (Cls && Cls.prototype && typeof Cls.prototype.handleProcessor === 'function' && !Cls.prototype.handleProcessor.__azifyPatched) {
+            const store = require('./store')
+            const toTraceIdHex = store.toTraceIdHex
+            const startRequestContext = store.startRequestContext
+            const setLastJobContext = store.setLastJobContext
+            const originalHandleProcessor = Cls.prototype.handleProcessor
+            Cls.prototype.handleProcessor = function(instance, key, queue, moduleRef, isRequestScoped, options) {
+              const self = this
+              const origArgs = [instance, key, queue, moduleRef, isRequestScoped, options]
+              const queueRef = queue
+              const wrapProcessor = (processor) => {
+                if (typeof processor !== 'function') return processor
+                return function(job) {
+                  let ctx = null
+                  try {
+                    const data = job && job.data
+                    const rawTraceId = data && data.traceId
+                    const traceId = rawTraceId ? toTraceIdHex(String(rawTraceId)) : null
+                    const spanId = data && data.spanId != null ? String(data.spanId).slice(0, 16) : null
+                    if (traceId && spanId) ctx = { traceId, spanId, parentSpanId: data?.parentSpanId ?? null, requestId: data?.requestId ?? null }
+                    else { let r = ''; try { r = (require('crypto').randomUUID && require('crypto').randomUUID()) || '' } catch (_) {}; ctx = startRequestContext({ requestId: r }) }
+                  } catch (_) {}
+                  if (!ctx) ctx = startRequestContext({})
+                  setLastJobContext(ctx)
+                  return processor(job)
+                }
+              }
+              const origProcess = queueRef.process
+              queueRef.process = function(...args) {
+                if (args.length > 0 && typeof args[args.length - 1] === 'function') {
+                  args[args.length - 1] = wrapProcessor(args[args.length - 1])
+                }
+                return origProcess.apply(this, args)
+              }
+              try {
+                return originalHandleProcessor.apply(self, origArgs)
+              } finally {
+                queueRef.process = origProcess
+              }
             }
+            Cls.prototype.handleProcessor.__azifyPatched = true
           }
-          
-          try {
-            const activeContext = otelContext.active()
-            const span = trace.getSpan(activeContext)
-            if (span) {
-              const spanContext = span.spanContext()
-              if (spanContext && spanContext.traceId && spanContext.spanId) {
+        } catch (_) {}
+      }
+
+      if (!skipBullPatch && pathNorm.includes('bullmq') && pathNorm.includes('processor-decorator')) {
+        try {
+          const Cls = (result && result.ProcessorDecoratorService) || result
+          if (Cls && Cls.prototype && typeof Cls.prototype.decorate === 'function' && !Cls.prototype.decorate.__azifyPatched) {
+            const store = require('./store')
+            const als = store.als
+            const toTraceIdHex = store.toTraceIdHex
+            const startRequestContext = store.startRequestContext
+            const setLastJobContext = store.setLastJobContext
+            const originalDecorate = Cls.prototype.decorate
+            Cls.prototype.decorate = function(processor) {
+              const decorated = originalDecorate.call(this, processor)
+              if (typeof decorated !== 'function') return decorated
+              return function(job, token, signal) {
+                let ctx = null
                 try {
-                  const propagation = require('@opentelemetry/api').propagation
-                  if (propagation && propagation.inject) {
-                    propagation.inject(activeContext, options.headers)
+                  const data = job && job.data
+                  const rawTraceId = data && data.traceId
+                  const traceId = rawTraceId ? toTraceIdHex(String(rawTraceId)) : null
+                  const spanId = data && data.spanId != null ? String(data.spanId).slice(0, 16) : null
+                  if (traceId && spanId) ctx = { traceId, spanId, parentSpanId: data?.parentSpanId ?? null, requestId: data?.requestId ?? null }
+                  else { let r = ''; try { r = (require('crypto').randomUUID && require('crypto').randomUUID()) || '' } catch (_) {}; ctx = startRequestContext({ requestId: r }) }
+                } catch (_) {}
+                if (!ctx) ctx = startRequestContext({})
+                setLastJobContext(ctx)
+                return als.run(ctx, function() { return decorated(job, token, signal) })
+              }
+            }
+            Cls.prototype.decorate.__azifyPatched = true
+          }
+        } catch (_) {}
+      }
+
+      const isPino = id === 'pino' || (typeof id === 'string' && (id.endsWith('/pino') || (pathNorm.includes('/pino') && !pathNorm.includes('nestjs-pino'))))
+      if (isPino) {
+        if (result && typeof result === 'function') {
+          if (debug) process.stderr.write(`[azify-logger] require hook patching pino id=${id}\n`)
+          const { getRequestContext, getLastJobContext } = require('./store')
+          const originalPino = result
+          const patchedPino = function(options, stream) {
+            if (new.target) {
+              return originalPino.call(this, options, stream)
+            }
+            const logger = originalPino(options, stream)
+            if (logger.__azifyPatched) return logger
+            logger.__azifyPatched = true
+            const originalLog = logger.log
+            const originalInfo = logger.info
+            const originalError = logger.error
+            const originalWarn = logger.warn
+            const originalDebug = logger.debug
+            const originalFatal = logger.fatal
+            const originalTrace = logger.trace
+            const originalChild = logger.child
+            const levelMap = { log: 'info', info: 'info', error: 'error', warn: 'warn', debug: 'debug', fatal: 'fatal', trace: 'trace' }
+            const { toTraceIdHex } = require('./store')
+            const patchLog = (original, methodName) => {
+              return function(obj, msg, ...args) {
+                let ctx = getRequestContext()
+                if (!ctx || !ctx.traceId) {
+                  const jobCtx = getLastJobContext()
+                  if (jobCtx && jobCtx.traceId) ctx = jobCtx
+                }
+                const otelCtx = getOtelTraceContext()
+                let traceId = ctx?.traceId
+                let spanId = ctx?.spanId
+                if (typeof obj === 'object' && obj !== null && (obj.traceId || obj.data?.traceId)) {
+                  traceId = obj.traceId || (obj.data && obj.data.traceId)
+                  spanId = obj.spanId != null ? obj.spanId : (obj.data && obj.data.spanId)
+                }
+                const msgStr = (typeof obj === 'object' ? obj?.message : obj) ?? msg ?? ''
+                if (!traceId && typeof msgStr === 'string' && /traceId/i.test(msgStr)) {
+                  const m = msgStr.match(/"traceId"\s*:\s*"([^"]+)"/)
+                  if (m) { traceId = m[1]; const s = msgStr.match(/"spanId"\s*:\s*"([^"]+)"/); spanId = s ? s[1] : null }
+                }
+                let traceCtx = traceId ? { traceId: toTraceIdHex(String(traceId)), spanId: spanId != null ? String(spanId).slice(0, 16) : null, parentSpanId: ctx?.parentSpanId ?? null, requestId: ctx?.requestId ?? null } : (ctx || otelCtx)
+                if (!traceCtx || !traceCtx.traceId) {
+                  try {
+                    const { startRequestContext } = require('./store')
+                    traceCtx = startRequestContext({})
+                  } catch (_) {
+                    traceCtx = { traceId: require('crypto').randomUUID ? require('crypto').randomUUID().replace(/-/g, '') : String(Date.now()), spanId: null, parentSpanId: null, requestId: null }
                   }
+                }
+                try {
+                  const out = (typeof obj === 'object' && obj !== null) ? { ...obj, traceId: traceCtx.traceId, spanId: traceCtx.spanId, parentSpanId: traceCtx.parentSpanId, requestId: traceCtx.requestId || ctx?.requestId } : { traceId: traceCtx.traceId, spanId: traceCtx.spanId, parentSpanId: traceCtx.parentSpanId, requestId: traceCtx.requestId || ctx?.requestId, msg: obj }
+                  const message = (typeof out === 'object' ? out.message : out) || msg || ''
+                  const meta = { ...out, service: { name: serviceName, version: '1.0.0' }, environment, timestamp: new Date().toISOString(), hostname: require('os').hostname() }
+                  sendOutboundLog(levelMap[methodName] || 'info', message, meta)
                 } catch (_) {}
+                return original.call(this, obj, msg, ...args)
               }
             }
-          } catch (_) {          }
+            logger.log = patchLog(originalLog, 'log')
+            logger.info = patchLog(originalInfo, 'info')
+            logger.error = patchLog(originalError, 'error')
+            logger.warn = patchLog(originalWarn, 'warn')
+            logger.debug = patchLog(originalDebug, 'debug')
+            logger.fatal = patchLog(originalFatal, 'fatal')
+            logger.trace = patchLog(originalTrace, 'trace')
+            logger.child = function(bindings, options) {
+              const childLogger = originalChild.call(this, bindings, options)
+              if (childLogger && !childLogger.__azifyPatched) {
+                childLogger.__azifyPatched = true
+                childLogger.log = patchLog(childLogger.log || (() => {}), 'log')
+                childLogger.info = patchLog(childLogger.info || (() => {}), 'info')
+                childLogger.error = patchLog(childLogger.error || (() => {}), 'error')
+                childLogger.warn = patchLog(childLogger.warn || (() => {}), 'warn')
+                childLogger.debug = patchLog(childLogger.debug || (() => {}), 'debug')
+                childLogger.fatal = patchLog(childLogger.fatal || (() => {}), 'fatal')
+                childLogger.trace = patchLog(childLogger.trace || (() => {}), 'trace')
+              }
+              return childLogger
+            }
+            return logger
+          }
+          Object.setPrototypeOf(patchedPino, originalPino)
+          Object.assign(patchedPino, originalPino)
+          return patchedPino
         }
-        
-        const wrappedCallback = callback ? function(err, data) {
-          const duration = Number((performance.now() - startTime).toFixed(2))
-          
-          if (err) {
-            const shouldLogError = HTTP_CLIENT_MODE === 'all' || HTTP_CLIENT_MODE === 'errors'
-            if (shouldLogError) {
-              const errorMeta = {
-                ...requestMeta,
-                error: err.message,
-                responseTimeMs: duration
+      }
+
+      if (id === 'undici' || id.includes('undici')) {
+        try {
+          if (debug) try { process.stderr.write(`[azify-logger] applyPatchesToModule UNDICI id=${(typeof id === 'string' ? id.slice(-50) : id)} hasRequest=${!!(result && result.request)}\n`) } catch (_) {}
+          const patchUndiciRequest = (target, label) => {
+            if (!target || typeof target.request !== 'function' || target.request.__azifyPatched) return
+            if (debug) process.stderr.write(`[azify-logger] patching undici ${label}\n`)
+            const { randomBytes } = require('crypto')
+            const { performance } = require('perf_hooks')
+            const { markSource, HTTP_CLIENT_MODE } = require('./sampling')
+            const { getRequestContext, toTraceIdHex } = require('./store')
+            const originalRequest = target.request
+            target.request = function(url, options, callback) {
+              const { getLastJobContext } = require('./store')
+              const ctx = getRequestContext() || getLastJobContext()
+              const otelCtx = getOtelTraceContext()
+              const traceCtx = ctx || otelCtx
+              const method = (options?.method || 'GET').toUpperCase()
+              const urlString = typeof url === 'string' ? url : (url && url.toString && url.toString()) || 'unknown'
+              const rawTraceId = traceCtx?.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
+              const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+              const parentSpanId = traceCtx?.spanId || null
+              const requestId = traceCtx?.requestId || ctx?.requestId || (require('crypto').randomUUID && require('crypto').randomUUID())
+              const spanId = randomBytes(8).toString('hex')
+              const requestMeta = { traceId, spanId, parentSpanId, requestId, method, url: urlString }
+              markSource(requestMeta, 'http-client')
+              const startTime = performance.now()
+              if (HTTP_CLIENT_MODE !== 'off') {
+                sendOutboundLog('info', `[REQUEST] ${method} ${urlString}`, requestMeta)
+              }
+              if (traceCtx && traceCtx.traceId) {
+                const headers = (options && options.headers) || {}
+                options = { ...options, headers: { ...headers, 'X-Trace-ID': traceId, 'X-Span-ID': spanId, 'X-Parent-Span-ID': traceCtx.parentSpanId || '', 'X-Request-ID': requestId } }
+              }
+              const wrappedCb = callback ? function(err, data) {
+                const duration = Number((performance.now() - startTime).toFixed(2))
+                if (HTTP_CLIENT_MODE !== 'off') {
+                  if (err) sendOutboundLog('error', `[RESPONSE] ${method} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: err.message, responseTimeMs: duration })
+                  else if (data) sendOutboundLog('info', `[RESPONSE] ${method} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                }
+                return callback(err, data)
+              } : undefined
+              if (wrappedCb) return originalRequest.call(this, url, options, wrappedCb)
+              const promise = originalRequest.call(this, url, options)
+              if (promise && typeof promise.then === 'function') {
+                return promise.then(
+                  (data) => {
+                    const duration = Number((performance.now() - startTime).toFixed(2))
+                    if (HTTP_CLIENT_MODE !== 'off' && data) {
+                      sendOutboundLog('info', `[RESPONSE] ${method} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                    }
+                    return data
+                  },
+                  (err) => {
+                    const duration = Number((performance.now() - startTime).toFixed(2))
+                    if (HTTP_CLIENT_MODE !== 'off') {
+                      sendOutboundLog('error', `[RESPONSE] ${method} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: (err && err.message) || String(err), responseTimeMs: duration })
+                    }
+                    throw err
+                  }
+                )
               }
-              sendOutboundLog('error', `[RESPONSE] ${method} ${urlString} ERROR ${duration}ms`, errorMeta)
+              return promise
             }
-          } else if (data) {
-            const statusCode = data.statusCode
-            const shouldLogResponse = HTTP_CLIENT_MODE === 'all' || (HTTP_CLIENT_MODE === 'errors' && statusCode >= 400)
-            
-            if (shouldLogResponse) {
-              const responseMeta = {
-                ...requestMeta,
-                statusCode,
-                responseTimeMs: duration
+            target.request.__azifyPatched = true
+          }
+          if (result && result.request) patchUndiciRequest(result, 'request')
+          if (result && result.Dispatcher && result.Dispatcher.prototype && typeof result.Dispatcher.prototype.request === 'function' && !result.Dispatcher.prototype.request.__azifyPatched) {
+            if (debug) process.stderr.write('[azify-logger] patching undici Dispatcher.prototype.request\n')
+            const { randomBytes } = require('crypto')
+            const { performance } = require('perf_hooks')
+            const { markSource, HTTP_CLIENT_MODE } = require('./sampling')
+            const { getRequestContext, toTraceIdHex } = require('./store')
+            const proto = result.Dispatcher.prototype
+            const origDispRequest = proto.request
+            proto.request = function(opts, callback) {
+              const { getLastJobContext } = require('./store')
+              const ctx = getRequestContext() || getLastJobContext()
+              const otelCtx = getOtelTraceContext()
+              const traceCtx = ctx || otelCtx
+              const method = (opts && (opts.method || 'GET')) || 'GET'
+              const methodStr = String(method).toUpperCase()
+              const origin = (opts && opts.origin) || ''
+              const path = (opts && opts.path) != null ? opts.path : '/'
+              const urlString = origin ? (origin + (path.startsWith('/') ? path : '/' + path)) : 'unknown'
+              const rawTraceId = traceCtx?.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
+              const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+              const parentSpanId = traceCtx?.spanId || null
+              const requestId = traceCtx?.requestId || ctx?.requestId || (require('crypto').randomUUID && require('crypto').randomUUID())
+              const spanId = randomBytes(8).toString('hex')
+              const requestMeta = { traceId, spanId, parentSpanId, requestId, method: methodStr, url: urlString }
+              markSource(requestMeta, 'http-client')
+              const startTime = performance.now()
+              if (HTTP_CLIENT_MODE !== 'off') {
+                sendOutboundLog('info', `[REQUEST] ${methodStr} ${urlString}`, requestMeta)
               }
-              sendOutboundLog('info', `[RESPONSE] ${method} ${urlString} ${statusCode} ${duration}ms`, responseMeta)
+              if (traceCtx && traceCtx.traceId && opts && typeof opts === 'object') {
+                const headers = { ...(opts.headers || {}), 'X-Trace-ID': traceId, 'X-Span-ID': spanId, 'X-Parent-Span-ID': traceCtx.parentSpanId || '', 'X-Request-ID': requestId }
+                opts = { ...opts, headers }
+              }
+              const wrappedCb = typeof callback === 'function' ? function(err, data) {
+                const duration = Number((performance.now() - startTime).toFixed(2))
+                if (HTTP_CLIENT_MODE !== 'off') {
+                  if (err) sendOutboundLog('error', `[RESPONSE] ${methodStr} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+                  else if (data) sendOutboundLog('info', `[RESPONSE] ${methodStr} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                }
+                return callback(err, data)
+              } : undefined
+              const ret = wrappedCb ? origDispRequest.call(this, opts, wrappedCb) : origDispRequest.call(this, opts)
+              if (ret && typeof ret.then === 'function' && !wrappedCb) {
+                return ret.then(
+                  (data) => {
+                    const duration = Number((performance.now() - startTime).toFixed(2))
+                    if (HTTP_CLIENT_MODE !== 'off' && data) {
+                      sendOutboundLog('info', `[RESPONSE] ${methodStr} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                    }
+                    return data
+                  },
+                  (err) => {
+                    const duration = Number((performance.now() - startTime).toFixed(2))
+                    if (HTTP_CLIENT_MODE !== 'off') {
+                      sendOutboundLog('error', `[RESPONSE] ${methodStr} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: (err && err.message) || String(err), responseTimeMs: duration })
+                    }
+                    throw err
+                  }
+                )
+              }
+              return ret
             }
+            proto.request.__azifyPatched = true
           }
-          
-          return callback(err, data)
-        } : undefined
-        
-        if (callback) {
-          return originalRequest.call(this, url, options, wrappedCallback)
-        }
-        
-        const result = originalRequest.call(this, url, options)
-        
-        if (result && typeof result.then === 'function') {
-          return result.then(
-            (data) => {
-              const duration = Number((performance.now() - startTime).toFixed(2))
-              const statusCode = data.statusCode
-              const shouldLogResponse = HTTP_CLIENT_MODE === 'all' || (HTTP_CLIENT_MODE === 'errors' && statusCode >= 400)
-              
-              if (shouldLogResponse) {
-                const responseMeta = {
-                  ...requestMeta,
-                  statusCode,
-                  responseTimeMs: duration
+          try {
+            const cache = require.cache
+            if (cache && typeof cache === 'object') {
+              for (const key of Object.keys(cache)) {
+                if (typeof key !== 'string') continue
+                const p = key.replace(/\\/g, '/')
+                if (p.indexOf('node_modules') === -1 || p.indexOf('undici') === -1 || p.includes('undici-package')) continue
+                const mod = cache[key]
+                if (!mod || !mod.exports || mod.exports === result) continue
+                const ex = mod.exports
+                if (ex && ex.request) patchUndiciRequest(ex, 'request(cache)')
+                if (ex && ex.Dispatcher && ex.Dispatcher.prototype && typeof ex.Dispatcher.prototype.request === 'function' && !ex.Dispatcher.prototype.request.__azifyPatched) {
+                  const proto = ex.Dispatcher.prototype
+                  const origDispRequest = proto.request
+                  proto.request = function(opts, callback) {
+                    const { getLastJobContext } = require('./store')
+                    const ctx = getRequestContext() || getLastJobContext()
+                    const otelCtx = getOtelTraceContext()
+                    const traceCtx = ctx || otelCtx
+                    const method = (opts && (opts.method || 'GET')) || 'GET'
+                    const methodStr = String(method).toUpperCase()
+                    const origin = (opts && opts.origin) || ''
+                    const path = (opts && opts.path) != null ? opts.path : '/'
+                    const urlString = origin ? (origin + (path.startsWith('/') ? path : '/' + path)) : 'unknown'
+                    const rawTraceId = traceCtx?.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
+                    const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+                    const parentSpanId = traceCtx?.spanId || null
+                    const requestId = traceCtx?.requestId || ctx?.requestId || (require('crypto').randomUUID && require('crypto').randomUUID())
+                    const spanId = randomBytes(8).toString('hex')
+                    const requestMeta = { traceId, spanId, parentSpanId, requestId, method: methodStr, url: urlString }
+                    markSource(requestMeta, 'http-client')
+                    const startTime = performance.now()
+                    if (HTTP_CLIENT_MODE !== 'off') {
+                      sendOutboundLog('info', `[REQUEST] ${methodStr} ${urlString}`, requestMeta)
+                    }
+                    if (traceCtx && traceCtx.traceId && opts && typeof opts === 'object') {
+                      const headers = { ...(opts.headers || {}), 'X-Trace-ID': traceId, 'X-Span-ID': spanId, 'X-Parent-Span-ID': traceCtx.parentSpanId || '', 'X-Request-ID': requestId }
+                      opts = { ...opts, headers }
+                    }
+                    const wrappedCb = typeof callback === 'function' ? function(err, data) {
+                      const duration = Number((performance.now() - startTime).toFixed(2))
+                      if (HTTP_CLIENT_MODE !== 'off') {
+                        if (err) sendOutboundLog('error', `[RESPONSE] ${methodStr} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+                        else if (data) sendOutboundLog('info', `[RESPONSE] ${methodStr} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                      }
+                      return callback(err, data)
+                    } : undefined
+                    const ret = wrappedCb ? origDispRequest.call(this, opts, wrappedCb) : origDispRequest.call(this, opts)
+                    if (ret && typeof ret.then === 'function' && !wrappedCb) {
+                      return ret.then(
+                        (data) => {
+                          const duration = Number((performance.now() - startTime).toFixed(2))
+                          if (HTTP_CLIENT_MODE !== 'off' && data) {
+                            sendOutboundLog('info', `[RESPONSE] ${methodStr} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                          }
+                          return data
+                        },
+                        (err) => {
+                          const duration = Number((performance.now() - startTime).toFixed(2))
+                          if (HTTP_CLIENT_MODE !== 'off') {
+                            sendOutboundLog('error', `[RESPONSE] ${methodStr} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: (err && err.message) || String(err), responseTimeMs: duration })
+                          }
+                          throw err
+                        }
+                      )
+                    }
+                    return ret
+                  }
+                  proto.request.__azifyPatched = true
                 }
-                sendOutboundLog('info', `[RESPONSE] ${method} ${urlString} ${statusCode} ${duration}ms`, responseMeta)
               }
-              
-              return data
+            }
+          } catch (_) {}
+        } catch (_) {}
+      }
+    }
+    try {
+      const origLoad = Module._load
+      if (origLoad && origLoad.__azifyEarlyPatched) {
+        if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] Module._load (late) keeping early hook (not overwriting)\n') } catch (_) {}
+      } else if (typeof origLoad === 'function' && !Module._load.__azifyPatched) {
+        Module._load = function (request, parent, isMain) {
+          const result = origLoad.apply(this, arguments)
+          const pathStr = typeof request === 'string' ? request.replace(/\\/g, '/') : ''
+          const isUndici = pathStr === 'undici' || (pathStr.indexOf('undici') !== -1 && pathStr.indexOf('undici-package') === -1)
+          if (isUndici) {
+            if (debug) try { process.stderr.write(`[azify-logger] Module._load UNDICI path=${pathStr.slice(-70)}\n`) } catch (_) {}
+            try {
+              applyPatchesToModule(result, pathStr)
+            } catch (_) {}
+          }
+          return result
+        }
+        Module._load.__azifyPatched = true
+        if (debug) try { process.stderr.write('[azify-logger] Module._load hook installed\n') } catch (_) {}
+      }
+    } catch (_) {}
+    try {
+      const Ritm = require('require-in-the-middle')
+      const Hook = Ritm && (Ritm.Hook || Ritm)
+      if (typeof Hook === 'function') {
+        new Hook(['undici', 'nestjs-pino', 'pino'], function (exports, name) {
+          const replaced = applyPatchesToModule(exports, name)
+          return (replaced !== undefined && replaced !== null) ? replaced : exports
+        })
+      }
+    } catch (_) {}
+    Module.prototype.require = function(id) {
+      const idStr = typeof id === 'string' ? id : ''
+      const pathNorm = idStr.replace(/\\/g, '/')
+      const isPinoOrNest = id === 'pino' || id === 'nestjs-pino' || pathNorm.includes('nestjs-pino') || pathNorm.includes('/pino')
+      if (debug && isPinoOrNest) {
+        try { process.stderr.write(`[azify-logger] REQUIRE_HOOK_BEFORE id=${idStr.slice(-80)}\n`) } catch (_) {}
+      }
+      if (isAzifyLoggerInternal(id)) return bypassRequire.call(this, id)
+      if (callerIsAzifyLogger.call(this)) {
+        const isPatchable = patchableIds.some(m => id === m || (typeof id === 'string' && id.includes(m)))
+        if (!isPatchable) return bypassRequire.call(this, id)
+      }
+      const result = originalRequire.call(this, id)
+      const idLooksLikeUndici = idStr === 'undici' || (pathNorm.indexOf('undici') !== -1 && pathNorm.indexOf('undici-package') === -1)
+      const undiciNeedsPatch = result && (typeof result.request === 'function' && !result.request.__azifyPatched || typeof result.fetch === 'function' && !result.fetch.__azifyPatched)
+      if (idLooksLikeUndici || undiciNeedsPatch) {
+        if (debug) try { process.stderr.write('[AZIFY] REGISTER require undici caller=' + (this && typeof this.filename === 'string' ? String(this.filename).replace(/\\/g, '/').slice(-85) : '') + ' patched=' + !!(result && result.request && result.request.__azifyPatched) + '\n') } catch (_) {}
+        if (process.env.AZIFY_LOGGER_HTTP_DEBUG === '1' || process.env.AZIFY_LOGGER_DEBUG === '1') {
+          try { process.stderr.write('[AZIFY-HTTP] REGISTER_HOOK2 patch id=' + idStr.slice(-70) + '\n') } catch (_) {}
+        }
+        try {
+          const early = require('./register-http-client-early')
+          if (typeof early.patchUndiciExports === 'function') early.patchUndiciExports(result)
+        } catch (_) {}
+      }
+      if (debug && (idLooksLikeUndici || undiciNeedsPatch)) {
+        try { process.stderr.write(`[azify-logger] REQUIRE_HOOK undici id=${idStr.slice(-60)} hasRequest=${!!(result && result.request)}\n`) } catch (_) {}
+      }
+      if (debug && isPinoOrNest) {
+        try { process.stderr.write(`[azify-logger] REQUIRE_HOOK_AFTER id=${idStr.slice(-80)} hasResult=${!!result}\n`) } catch (_) {}
+      }
+      const replaced = applyPatchesToModule(result, id)
+      return (replaced !== undefined && replaced !== null) ? replaced : result
+    }
+    if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+      try { process.stderr.write('[azify-logger] REGISTER step3 second hook set\n') } catch (_) {}
+    }
+    let walkRunCount = 0
+    function walkCacheAndPatch() {
+      try {
+        walkRunCount++
+        const cache = require.cache
+        const keys = cache && typeof cache === 'object' ? Object.keys(cache) : []
+        if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+          try { process.stderr.write(`[azify-logger] walkCache #${walkRunCount} keys=${keys.length}\n`) } catch (_) {}
+        }
+        if (cache && typeof cache === 'object') {
+          if (debug && keys.length > 0) {
+            const pinoRelated = keys.filter(k => typeof k === 'string' && (k.includes('pino') || k.includes('nestjs') || k.includes('undici')))
+            if (walkRunCount <= 3 || pinoRelated.length > 0) {
+              try {
+                const preview = pinoRelated.length ? ' -> ' + pinoRelated.map(k => k.replace(/\\/g, '/').slice(-55)).join(' | ') : ''
+                process.stderr.write(`[azify-logger] walkCache #${walkRunCount}: ${keys.length} keys, ${pinoRelated.length} pino/nest/undici${preview}\n`)
+              } catch (_) {}
+            }
+          }
+          for (const key of keys) {
+            if (typeof key !== 'string') continue
+            const pathNorm = key.replace(/\\/g, '/')
+            if (!pathNorm.includes('undici') && !pathNorm.includes('nestjs-pino') && !pathNorm.includes('/pino') && !pathNorm.includes('bullmq') && !pathNorm.includes('/bull') && !pathNorm.includes('@nestjs/common')) continue
+            const mod = cache[key]
+            if (!mod || !mod.exports) continue
+            if (debug && (pathNorm.includes('nestjs-pino') || pathNorm.includes('undici'))) {
+              try { process.stderr.write(`[azify-logger] walkCache PATCHING key=${pathNorm.slice(-70)}\n`) } catch (_) {}
+            }
+            const replaced = applyPatchesToModule(mod.exports, key)
+            if (replaced !== undefined && replaced !== null) mod.exports = replaced
+          }
+        }
+      } catch (e) {
+        if (debug) try { process.stderr.write(`[azify-logger] walkCache err: ${e && e.message}\n`) } catch (_) {}
+      }
+    }
+    if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+      try { process.stderr.write('[azify-logger] about to call walkCacheAndPatch\n') } catch (_) {}
+    }
+    walkCacheAndPatch()
+    try {
+      setTransport(createHttpLoggerTransport(loggerUrlString))
+    } catch (_) {}
+    try {
+      require('undici')
+      if (debug) try { process.stderr.write('[azify-logger] eager require(undici) done\n') } catch (_) {}
+    } catch (_) {}
+    walkCacheAndPatch()
+    try {
+      if (typeof globalThis.fetch === 'function' && !globalThis.fetch.__azifyPatched) {
+        const origFetch = globalThis.fetch
+        globalThis.fetch = function(url, opts) {
+          const { getRequestContext, getLastJobContext, toTraceIdHex } = require('./store')
+          const ctx = getRequestContext() || getLastJobContext()
+          const otelCtx = getOtelTraceContext()
+          const traceCtx = ctx || otelCtx
+          const method = (opts && opts.method) ? String(opts.method).toUpperCase() : 'GET'
+          const urlStr = typeof url === 'string' ? url : (url && url.url) ? url.url : (url && url.toString && url.toString()) || 'unknown'
+          const rawTraceId = traceCtx?.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
+          const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+          const requestMeta = { traceId, spanId: traceCtx?.spanId || null, parentSpanId: traceCtx?.parentSpanId || null, requestId: traceCtx?.requestId || null, method, url: urlStr }
+          markSource(requestMeta, 'http-client')
+          const start = require('perf_hooks').performance.now()
+          if (HTTP_CLIENT_MODE !== 'off') {
+            sendOutboundLog('info', `[REQUEST] ${method} ${urlStr}`, requestMeta)
+          }
+          return origFetch.apply(this, arguments).then(
+            (res) => {
+              const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+              if (HTTP_CLIENT_MODE !== 'off') {
+                sendOutboundLog('info', `[RESPONSE] ${method} ${urlStr} ${res.status} ${duration}ms`, { ...requestMeta, statusCode: res.status, responseTimeMs: duration })
+              }
+              return res
             },
             (err) => {
-              const duration = Number((performance.now() - startTime).toFixed(2))
-              const shouldLogError = HTTP_CLIENT_MODE === 'all' || HTTP_CLIENT_MODE === 'errors'
-              if (shouldLogError) {
-                const errorMeta = {
-                  ...requestMeta,
-                  error: err.message || String(err),
-                  responseTimeMs: duration
-                }
-                sendOutboundLog('error', `[RESPONSE] ${method} ${urlString} ERROR ${duration}ms`, errorMeta)
+              const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
+              if (HTTP_CLIENT_MODE !== 'off') {
+                sendOutboundLog('error', `[RESPONSE] ${method} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
               }
-              
               throw err
             }
           )
         }
-        
-        return result
+        globalThis.fetch.__azifyPatched = true
+        if (debug) try { process.stderr.write('[azify-logger] patched globalThis.fetch\n') } catch (_) {}
       }
+    } catch (_) {}
+    if (debug) try { process.stderr.write('[azify-logger] REGISTER_END Module.prototype.require hook installed + walkCacheAndPatch done\n') } catch (_) {}
+    if (typeof setImmediate === 'function') {
+      setImmediate(walkCacheAndPatch)
     }
-  } catch (_) {}
+    ;[0, 50, 200, 500, 1000].forEach(function (delay) {
+      if (typeof setTimeout === 'function') {
+        setTimeout(walkCacheAndPatch, delay)
+      }
+    })
+  } catch (e) {
+    if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+      try {
+        process.stderr.write('[azify-logger] REGISTER main catch hit\n')
+        const msg = e && (e.message || (e.stack && e.stack.split('\n')[0]) || String(e))
+        process.stderr.write('[azify-logger] REGISTER main catch: ' + msg + '\n')
+        if (e && e.stack) process.stderr.write(e.stack + '\n')
+      } catch (_) {}
+    }
+  }
 
   try {
+    const ModuleForAxios = require('module')
+    const origRequireAxios = ModuleForAxios.prototype.require
+    let applyAxiosPatch = null
+    if (typeof origRequireAxios === 'function' && !origRequireAxios.__azifyAxiosHookInstalled) {
+      ModuleForAxios.prototype.require = function (id) {
+        const result = origRequireAxios.apply(this, arguments)
+        const idStr = typeof id === 'string' ? id.replace(/\\/g, '/') : ''
+        const isAxios = idStr === 'axios' || idStr.endsWith('/axios') || (idStr.includes('axios') && idStr.indexOf('axios-') === -1)
+        if (isAxios && result && typeof result === 'object' && !result.__azifyLoggerPatched && applyAxiosPatch) {
+          try { applyAxiosPatch(result) } catch (_) {}
+        }
+        return result
+      }
+      ModuleForAxios.prototype.require.__azifyAxiosHookInstalled = true
+    }
     const axios = require('axios')
     if (axios) {
-      const { getRequestContext, runWithRequestContext } = require('./store')
+      const { getRequestContext, getLastJobContext, runWithRequestContext } = require('./store')
 
       const buildUrl = (config) => {
         const url = config.url || ''
@@ -648,7 +1558,7 @@ try {
               return config
             }
 
-            const ctx = getRequestContext()
+            const ctx = getRequestContext() || getLastJobContext()
             const traceId = (ctx?.traceId) || randomUUID()
             const parentSpanId = (ctx?.spanId) || null
             const requestId = (ctx?.requestId) || randomUUID()
@@ -686,6 +1596,7 @@ try {
               !!traceId
 
             if (shouldLogRequest) {
+              if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[AZIFY-DBG] axios REQUEST ' + method + ' ' + String(url).slice(0, 80) + '\n') } catch (_) {}
               sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
             }
 
@@ -717,7 +1628,7 @@ try {
 
               if (shouldLogResponse || hasTraceHeaders) {
                 const finalUrl = (url && url !== 'unknown') ? url : (marker?.meta?.url || response.config?.url || response.request?.responseURL || url)
-                
+
                 if (finalUrl && finalUrl !== 'unknown') {
                 let meta
                 let duration = 0
@@ -735,7 +1646,7 @@ try {
                     }
                   }
                 }
-                
+
                 if (marker && marker.meta) {
                   duration = Number((performance.now() - marker.start).toFixed(2))
                   let responseBodyString = stringifyBody(response.data)
@@ -752,7 +1663,7 @@ try {
                   }
                 } else {
                   const requestHeaders = response.config?.headers || {}
-                  const ctx = getRequestContext()
+                  const ctx = getRequestContext() || getLastJobContext()
                   const traceId = requestHeaders['x-trace-id'] || requestHeaders['X-Trace-ID'] || ctx?.traceId || randomUUID()
                   const spanId = requestHeaders['x-span-id'] || requestHeaders['X-Span-ID'] || randomBytes(8).toString('hex')
                   const parentSpanId = requestHeaders['x-parent-span-id'] || requestHeaders['X-Parent-Span-ID'] || ctx?.spanId || null
@@ -761,7 +1672,7 @@ try {
                   if (typeof responseBodyString === 'string' && responseBodyString.length > 5000) {
                     responseBodyString = responseBodyString.slice(0, 5000)
                   }
-                  
+
                   meta = {
                     traceId,
                     spanId,
@@ -775,11 +1686,11 @@ try {
                     responseBody: responseBodyString
                   }
                 }
-                
+
                 markSource(meta, 'http-client')
                 const message = `[RESPONSE] ${meta.method} ${meta.url} ${response.status} ${meta.responseTimeMs}ms`
                 const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
-                
+
                 sendOutboundLog(level, message, meta)
                 }
               }
@@ -807,7 +1718,7 @@ try {
               if (shouldLogError && url && url !== 'unknown') {
                 let meta
                 let duration = 0
-                
+
                 if (marker && marker.meta) {
                   duration = Number((performance.now() - marker.start).toFixed(2))
                   meta = {
@@ -824,12 +1735,12 @@ try {
                   }
                 } else {
                   const requestHeaders = config?.headers || {}
-                  const ctx = getRequestContext()
+                  const ctx = getRequestContext() || getLastJobContext()
                   const traceId = requestHeaders['x-trace-id'] || requestHeaders['X-Trace-ID'] || ctx?.traceId || randomUUID()
                   const spanId = requestHeaders['x-span-id'] || requestHeaders['X-Span-ID'] || randomBytes(8).toString('hex')
                   const parentSpanId = requestHeaders['x-parent-span-id'] || requestHeaders['X-Parent-Span-ID'] || ctx?.spanId || null
                   const requestId = requestHeaders['x-request-id'] || requestHeaders['X-Request-ID'] || ctx?.requestId || randomUUID()
-                  
+
                   meta = {
                     traceId,
                     spanId,
@@ -848,10 +1759,10 @@ try {
                     }
                   }
                 }
-                
+
                 markSource(meta, 'http-client')
                 const message = `[ERROR] ${meta.method} ${meta.url}`
-                
+
                 sendOutboundLog('error', message, meta)
               }
             } catch (err) {
@@ -864,13 +1775,27 @@ try {
         return instance
       }
 
-      patchInstance(axios)
-
-      if (axios.create) {
-        const originalCreate = axios.create
-        axios.create = function(config) {
-          const instance = originalCreate.call(this, config)
-          return patchInstance(instance)
+      applyAxiosPatch = function (ax) {
+        if (!ax || ax.__azifyLoggerPatched) return
+        patchInstance(ax)
+        if (ax.create) {
+          const originalCreate = ax.create
+          ax.create = function (config) {
+            const instance = originalCreate.call(this, config)
+            patchInstance(instance)
+            return instance
+          }
+        }
+      }
+      applyAxiosPatch(axios)
+      for (const key of Object.keys(require.cache || {})) {
+        if (typeof key !== 'string') continue
+        const keyNorm = key.replace(/\\/g, '/')
+        if (keyNorm === 'axios' || keyNorm.endsWith('/axios') || (keyNorm.includes('node_modules') && keyNorm.includes('/axios'))) {
+          const mod = require.cache[key]
+          if (mod && mod.exports && typeof mod.exports === 'object' && !mod.exports.__azifyLoggerPatched) {
+            try { applyAxiosPatch(mod.exports) } catch (_) {}
+          }
         }
       }
     }
@@ -882,7 +1807,7 @@ try {
       if (!g.__azifyLoggerFetchPatched) {
         g.__azifyLoggerFetchPatched = true
 
-        const { getRequestContext, runWithRequestContext } = require('./store')
+        const { getRequestContext, getLastJobContext, runWithRequestContext } = require('./store')
 
         const originalFetch = globalThis.fetch.bind(globalThis)
 
@@ -911,11 +1836,11 @@ try {
           if (HTTP_CLIENT_MODE === 'off') {
             return originalFetch(input, init)
           }
-          
+
           let request
           let method = 'UNKNOWN'
           let url = String(input)
-          
+
           try {
             request = ensureRequest(input, init)
             method = request.method.toUpperCase()
@@ -943,7 +1868,7 @@ try {
             return originalFetch(request)
           }
 
-          const ctx = getRequestContext()
+          const ctx = getRequestContext() || getLastJobContext()
           const traceId = (ctx?.traceId) || randomUUID()
           const parentSpanId = (ctx?.spanId) || null
           const requestId = (ctx?.requestId) || randomUUID()
@@ -1057,10 +1982,10 @@ try {
               }
               return {}
             }
-            
+
             let responseBodyString = null
             let responseHeaders = {}
-            
+
             try {
               responseHeaders = headersToObject(response.headers)
               const contentType = response.headers.get('content-type') || ''
@@ -1075,7 +2000,7 @@ try {
                   return null
                 }
               }
-              
+
               if (contentType.includes('application/json') || contentType.includes('text/')) {
                 try {
                   const clonedResponse = response.clone()
@@ -1117,18 +2042,18 @@ try {
               }
             } catch (_) {
             }
-            
+
             const responseMeta = {
               ...requestMeta,
               statusCode: response.status,
               responseTimeMs: duration,
               responseHeaders
             }
-            
+
             if (responseBodyString !== null) {
               responseMeta.responseBody = responseBodyString
             }
-            
+
             markSource(responseMeta, 'http-client')
             const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
             const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
@@ -1141,77 +2066,5 @@ try {
     }
   } catch (_) {}
 
-  try {
-    const Bull = require('bull')
-    const { runWithRequestContext } = require('./store')
-
-    const originalAdd = Bull.prototype.add
-    Bull.prototype.add = function(name, data, opts) {
-      const ctx = getRequestContext()
-
-      if (ctx && ctx.traceId) {
-        data = {
-          ...data,
-          traceId: ctx.traceId,
-          spanId: ctx.spanId,
-          parentSpanId: ctx.parentSpanId,
-          requestId: ctx.requestId,
-        }
-      }
-
-      return originalAdd.call(this, name, data, opts)
-    }
-
-    const originalProcess = Bull.prototype.process
-    Bull.prototype.process = function(name, concurrency, handler) {
-      let actualName, actualConcurrency, actualHandler
-
-      if (typeof name === 'function') {
-        actualHandler = name
-        actualName = '__default__'
-        actualConcurrency = 1
-      } else if (typeof concurrency === 'function') {
-        actualHandler = concurrency
-        actualName = name
-        actualConcurrency = 1
-      } else {
-        actualName = name
-        actualConcurrency = concurrency
-        actualHandler = handler
-      }
-
-      const wrappedHandler = function(job, done) {
-        const { traceId, spanId, parentSpanId, requestId, ...jobData } = job.data
-
-        if (traceId && spanId) {
-          const ctx = {
-            traceId,
-            spanId,
-            parentSpanId,
-            requestId,
-          }
-          
-          return runWithRequestContext(ctx, () => {
-            return actualHandler.call(this, job, done)
-          })
-        } else {
-          const { startRequestContext } = require('./store')
-          const newCtx = startRequestContext({ requestId: require('uuid').v4() })
-          
-          return runWithRequestContext(newCtx, () => {
-            return actualHandler.call(this, job, done)
-          })
-        }
-      }
-
-      if (typeof name === 'function') {
-        return originalProcess.call(this, wrappedHandler)
-      } else if (typeof concurrency === 'function') {
-        return originalProcess.call(this, actualName, wrappedHandler)
-      } else {
-        return originalProcess.call(this, actualName, actualConcurrency, wrappedHandler)
-      }
-    }
-  } catch (_) {}
 } catch (_) {}
 }