azify-logger 1.0.54 → 1.0.55-test-1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.54",
+  "version": "1.0.55-test-1",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -111,6 +111,7 @@
     "queue/",
     "scripts/redis-worker.js",
     "streams/",
+    "utils/undiciLogBodies.js",
     "package.json",
     "README.md"
   ]

package/register-http-client-early.js

@@ -11,6 +11,11 @@ try {
   const Module = require('module')
   const path = require('path')
   const EARLY_DIR = __dirname
+  const {
+    resolveUndiciRequestOpts,
+    serializeUndiciRequestBody,
+    restoreUndiciResponseBodyAfterReadForLog
+  } = require(path.join(EARLY_DIR, 'utils/undiciLogBodies'))
 
   function getOtelTraceContext() {
     try {
@@ -28,13 +33,70 @@ try {
   const MAX_EARLY_LOG_QUEUE = 2000
   const earlyLogQueue = []
 
+  function normalizePathEarly(p) {
+    if (!p) return '/'
+    const trimmed = String(p).replace(/\/+$/, '')
+    return trimmed === '' ? '/' : trimmed
+  }
+
+  /** Ignora esquema (http vs https): undici muitas vezes resolve como https e AZIFY_LOGGER_URL é http em dev. */
   function isLoggerUrl(urlStr) {
-    const loggerUrl = process.env.AZIFY_LOGGER_URL
-    if (!loggerUrl || typeof urlStr !== 'string' || !urlStr.trim()) return false
-    const a = String(urlStr).trim().toLowerCase().replace(/\/+$/, '')
-    const b = String(loggerUrl).trim().toLowerCase().replace(/\/+$/, '')
-    if (!b) return false
-    return a === b || a.startsWith(b + '/')
+    const loggerUrlRaw = process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log'
+    if (typeof urlStr !== 'string' || !urlStr.trim()) return false
+    try {
+      const base = new URL(String(loggerUrlRaw).trim())
+      const cand = new URL(String(urlStr).trim())
+      if (base.hostname.toLowerCase() !== cand.hostname.toLowerCase()) return false
+      const portBase = base.port || (base.protocol === 'https:' ? '443' : '80')
+      const portCand = cand.port || (cand.protocol === 'https:' ? '443' : '80')
+      if (String(portBase) !== String(portCand)) return false
+      const lp = normalizePathEarly(base.pathname)
+      const tp = normalizePathEarly(cand.pathname)
+      return tp === lp || tp.startsWith(lp + '/')
+    } catch (_) {
+      return false
+    }
+  }
+
+  /** undici.request(url, opts) / request(opts) — muitas chamadas não trazem origin; path pode ser URL absoluta ou só path + hostname. */
+  function resolveUrlStrFromUndiciRequestArgs(url, options) {
+    const opts = (typeof url === 'object' && url !== null && !(url instanceof URL)) ? url : options
+    const urlArg = (typeof url === 'string' || (url && (url.href || url instanceof URL))) ? url : (opts && (opts.url || opts.uri))
+    if (typeof urlArg === 'string') return urlArg
+    if (urlArg && typeof urlArg.href === 'string') return urlArg.href
+    if (urlArg && typeof urlArg.toString === 'function') return urlArg.toString()
+    if (opts && typeof opts.origin === 'string' && opts.path != null) {
+      return opts.origin + (String(opts.path).startsWith('/') ? '' : '/') + String(opts.path)
+    }
+    if (opts && typeof opts.path === 'string' && /^https?:\/\//i.test(opts.path)) {
+      return opts.path
+    }
+    if (opts && (opts.hostname || opts.host)) {
+      const h = String(opts.hostname || String(opts.host || '').split(':')[0]).trim()
+      if (h) {
+        const hl = h.toLowerCase()
+        const isLocal = hl === 'localhost' || hl === '127.0.0.1' || hl === '::1'
+        const proto = (opts.protocol && String(opts.protocol).replace(/:$/, '')) || (isLocal ? 'http' : 'https')
+        const pnum = opts.port != null && opts.port !== '' ? Number(opts.port) : NaN
+        const port = !Number.isNaN(pnum) && pnum !== 80 && pnum !== 443 ? ':' + pnum : ''
+        const p = opts.path != null ? String(opts.path) : '/'
+        return proto + '://' + h + port + (p.startsWith('/') ? p : '/' + p)
+      }
+    }
+    return 'unknown'
+  }
+
+  function resolveUrlStrFromDispatcherOpts(opts) {
+    if (!opts || typeof opts !== 'object') return 'unknown'
+    const origin = (opts.origin) || ''
+    const pathPart = opts.path != null ? opts.path : '/'
+    const pathStr = String(pathPart)
+    if (/^https?:\/\//i.test(pathStr)) return pathStr
+    if (origin) return origin + (pathStr.startsWith('/') ? pathStr : '/' + pathStr)
+    if (opts.hostname || opts.host) {
+      return resolveUrlStrFromUndiciRequestArgs(null, opts)
+    }
+    return 'unknown'
   }
 
   function send(level, message, meta) {
@@ -98,8 +160,19 @@ try {
   }
 
   function patchUndiciExports(exports) {
+    if (!exports || typeof exports !== 'object') return
+    if (typeof exports.fetch === 'function' && typeof globalThis.fetch === 'function' && globalThis.fetch.__azifyLoggerFetchPatched) {
+      if (exports.fetch !== globalThis.fetch) {
+        exports.fetch = globalThis.fetch
+        httpLog('undici exports.fetch -> globalThis.fetch (body logging)')
+      }
+    }
     const hasRequest = exports && typeof exports.request === 'function' && !exports.request.__azifyPatched
-    const hasFetch = exports && typeof exports.fetch === 'function' && !exports.fetch.__azifyPatched
+    const hasFetch =
+      exports &&
+      typeof exports.fetch === 'function' &&
+      !exports.fetch.__azifyPatched &&
+      !exports.fetch.__azifyLoggerFetchPatched
     if (!exports || (!hasRequest && !hasFetch)) return
     const deps = loadStoreAndSampling()
     const noDeps = !deps
@@ -118,12 +191,7 @@ try {
     exports.request = function (url, options, callback) {
       const opts = (typeof url === 'object' && url !== null && !(url instanceof URL)) ? url : options
       const method = ((opts && opts.method) || 'GET').toUpperCase()
-      let urlStr = 'unknown'
-      const urlArg = (typeof url === 'string' || (url && (url.href || url instanceof URL))) ? url : (opts && (opts.url || opts.uri))
-      if (typeof urlArg === 'string') urlStr = urlArg
-      else if (urlArg && typeof urlArg.href === 'string') urlStr = urlArg.href
-      else if (urlArg && typeof urlArg.toString === 'function') urlStr = urlArg.toString()
-      else if (opts && typeof opts.origin === 'string' && opts.path != null) urlStr = opts.origin + (String(opts.path).startsWith('/') ? '' : '/') + String(opts.path)
+      const urlStr = resolveUrlStrFromUndiciRequestArgs(url, options)
       if (process.env.AZIFY_LOGGER_DEBUG === '1') { try { process.stderr.write('[AZIFY-PATCH] undici.request ' + method + ' ' + urlStr.slice(0, 80) + '\n') } catch (_) {} }
       const _ep = process.env.AZIFY_DEBUG_LOG_PATH
       if (_ep) { try { require('fs').appendFileSync(_ep, new Date().toISOString() + ' [AZIFY] WRAPPER exports.request ' + method + ' ' + urlStr.slice(0, 100) + '\n') } catch (_) {} }
@@ -136,26 +204,50 @@ try {
       const traceCtx = ctx || otelCtx
       const rawTraceId = traceCtx && traceCtx.traceId || (require('crypto').randomUUID && require('crypto').randomUUID())
       const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+      const reqOpts = resolveUndiciRequestOpts(url, options)
+      const requestBodyStr = serializeUndiciRequestBody(reqOpts)
       const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method, url: urlStr }
+      if (requestBodyStr != null) requestMeta.requestBody = requestBodyStr
       markSource(requestMeta, 'http-client')
       const start = require('perf_hooks').performance.now()
       const skipLog = isLoggerUrl(urlStr)
       if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${method} ${urlStr}`, requestMeta)
       const wrappedCb = callback ? function (err, data) {
         const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
-        if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
-          if (err) send('error', `[RESPONSE] ${method} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
-          else if (data) send('info', `[RESPONSE] ${method} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+        if (err) {
+          if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+            send('error', `[RESPONSE] ${method} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+          }
+          return callback(err, data)
         }
-        return callback(err, data)
+        if (!data) return callback(err, data)
+        restoreUndiciResponseBodyAfterReadForLog(data).then(({ logStr, data: restored }) => {
+          if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+            const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+            if (logStr != null) meta.responseBody = logStr
+            send('info', `[RESPONSE] ${method} ${urlStr} ${restored.statusCode} ${duration}ms`, meta)
+          }
+          return callback(null, restored)
+        }).catch(() => {
+          if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+            send('info', `[RESPONSE] ${method} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+          }
+          return callback(null, data)
+        })
       } : undefined
       if (wrappedCb) return origRequest.call(this, url, options, wrappedCb)
       const p = origRequest.call(this, url, options)
       if (p && typeof p.then === 'function') {
         return p.then(
-          (data) => {
+          async (data) => {
             const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
-            if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) send('info', `[RESPONSE] ${method} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) {
+              const { logStr, data: restored } = await restoreUndiciResponseBodyAfterReadForLog(data)
+              const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+              if (logStr != null) meta.responseBody = logStr
+              send('info', `[RESPONSE] ${method} ${urlStr} ${restored.statusCode} ${duration}ms`, meta)
+              return restored
+            }
             return data
           },
           (err) => {
@@ -174,34 +266,55 @@ try {
       const origDisp = proto.request
       proto.request = function (opts, callback) {
         const methodStr = String((opts && opts.method) || 'GET').toUpperCase()
-        const origin = (opts && opts.origin) || ''
-        const path = (opts && opts.path) != null ? opts.path : '/'
-        const urlStr = origin ? (origin + (path.startsWith('/') ? path : '/' + path)) : 'unknown'
+        const urlStr = resolveUrlStrFromDispatcherOpts(opts)
         httpLog('WRAPPER Dispatcher.request ' + methodStr + ' ' + urlStr.slice(0, 80))
         const ctx = getRequestContext() || getLastJobContext()
         const otelCtx = getOtelTraceContext()
         const traceCtx = ctx || otelCtx
         const rawTraceId = (traceCtx && traceCtx.traceId) || (require('crypto').randomUUID && require('crypto').randomUUID())
         const traceId = typeof rawTraceId === 'string' ? toTraceIdHex(rawTraceId) : rawTraceId
+        const requestBodyStr = serializeUndiciRequestBody(opts || {})
         const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method: methodStr, url: urlStr }
+        if (requestBodyStr != null) requestMeta.requestBody = requestBodyStr
         markSource(requestMeta, 'http-client')
         const start = require('perf_hooks').performance.now()
         const skipLog = isLoggerUrl(urlStr)
         if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${methodStr} ${urlStr}`, requestMeta)
         const wrappedCb = typeof callback === 'function' ? function (err, data) {
           const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
-          if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
-            if (err) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
-            else if (data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+          if (err) {
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+              send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+            }
+            return callback(err, data)
           }
-          return callback(err, data)
+          if (!data) return callback(err, data)
+          restoreUndiciResponseBodyAfterReadForLog(data).then(({ logStr, data: restored }) => {
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+              const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+              if (logStr != null) meta.responseBody = logStr
+              send('info', `[RESPONSE] ${methodStr} ${urlStr} ${restored.statusCode} ${duration}ms`, meta)
+            }
+            return callback(null, restored)
+          }).catch(() => {
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+              send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+            }
+            return callback(null, data)
+          })
         } : undefined
         const ret = wrappedCb ? origDisp.call(this, opts, wrappedCb) : origDisp.call(this, opts)
         if (ret && typeof ret.then === 'function' && !wrappedCb) {
           return ret.then(
-            (data) => {
+            async (data) => {
               const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
-              if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) {
+                const { logStr, data: restored } = await restoreUndiciResponseBodyAfterReadForLog(data)
+                const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+                if (logStr != null) meta.responseBody = logStr
+                send('info', `[RESPONSE] ${methodStr} ${urlStr} ${restored.statusCode} ${duration}ms`, meta)
+                return restored
+              }
               return data
             },
             (err) => {
@@ -255,34 +368,55 @@ try {
         if (typeof origReq !== 'function') return d
         d.request = function (opts, callback) {
           const methodStr = String((opts && opts.method) || 'GET').toUpperCase()
-          const origin = (opts && opts.origin) || ''
-          const pathPart = (opts && opts.path) != null ? opts.path : '/'
-          const urlStr = origin ? (origin + (pathPart.startsWith('/') ? pathPart : '/' + pathPart)) : 'unknown'
+          const urlStr = resolveUrlStrFromDispatcherOpts(opts)
           httpLog('WRAPPER getGlobalDispatcher().request ' + methodStr + ' ' + urlStr.slice(0, 80))
           const ctx = getRequestContext ? getRequestContext() : (getLastJobContext ? getLastJobContext() : null)
           const otelCtx = getOtelTraceContext()
           const traceCtx = ctx || otelCtx
           const rawTraceId = (traceCtx && traceCtx.traceId) || (require('crypto').randomUUID && require('crypto').randomUUID())
           const traceId = typeof rawTraceId === 'string' ? (toTraceIdHex ? toTraceIdHex(rawTraceId) : rawTraceId) : rawTraceId
+          const requestBodyStr = serializeUndiciRequestBody(opts || {})
           const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method: methodStr, url: urlStr }
+          if (requestBodyStr != null) requestMeta.requestBody = requestBodyStr
           if (markSource) markSource(requestMeta, 'http-client')
           const start = require('perf_hooks').performance.now()
           const skipLog = isLoggerUrl(urlStr)
           if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${methodStr} ${urlStr}`, requestMeta)
           const wrappedCb = typeof callback === 'function' ? function (err, data) {
             const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
-            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
-              if (err) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
-              else if (data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+            if (err) {
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+                send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+              }
+              return callback(err, data)
             }
-            return callback(err, data)
+            if (!data) return callback(err, data)
+            restoreUndiciResponseBodyAfterReadForLog(data).then(({ logStr, data: restored }) => {
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+                const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+                if (logStr != null) meta.responseBody = logStr
+                send('info', `[RESPONSE] ${methodStr} ${urlStr} ${restored.statusCode} ${duration}ms`, meta)
+              }
+              return callback(null, restored)
+            }).catch(() => {
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+                send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+              }
+              return callback(null, data)
+            })
           } : undefined
           const ret = wrappedCb ? origReq.call(this, opts, wrappedCb) : origReq.call(this, opts)
           if (ret && typeof ret.then === 'function' && !wrappedCb) {
             return ret.then(
-              (data) => {
+              async (data) => {
                 const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
-                if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+                if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) {
+                  const { logStr, data: restored } = await restoreUndiciResponseBodyAfterReadForLog(data)
+                  const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+                  if (logStr != null) meta.responseBody = logStr
+                  send('info', `[RESPONSE] ${methodStr} ${urlStr} ${restored.statusCode} ${duration}ms`, meta)
+                  return restored
+                }
                 return data
               },
               (err) => {
@@ -333,9 +467,7 @@ try {
       const HTTP_CLIENT_MODE = deps ? deps.HTTP_CLIENT_MODE : 'all'
       d.request = function (opts, callback) {
         const methodStr = String((opts && opts.method) || 'GET').toUpperCase()
-        const origin = (opts && opts.origin) || ''
-        const pathPart = (opts && opts.path) != null ? opts.path : '/'
-        const urlStr = origin ? (origin + (pathPart.startsWith('/') ? pathPart : '/' + pathPart)) : 'unknown'
+        const urlStr = resolveUrlStrFromDispatcherOpts(opts)
         httpLog('WRAPPER globalThis.dispatcher.request ' + methodStr + ' ' + urlStr.slice(0, 80))
         const _dp = process.env.AZIFY_DEBUG_LOG_PATH
         if (_dp) { try { require('fs').appendFileSync(_dp, new Date().toISOString() + ' [AZIFY] WRAPPER globalDispatcher.request ' + methodStr + ' ' + urlStr.slice(0, 100) + '\n') } catch (_) {} }
@@ -344,25 +476,48 @@ try {
         const traceCtx = ctx || otelCtx
         const rawTraceId = (traceCtx && traceCtx.traceId) || (require('crypto').randomUUID && require('crypto').randomUUID())
         const traceId = typeof rawTraceId === 'string' ? (toTraceIdHex ? toTraceIdHex(rawTraceId) : rawTraceId) : rawTraceId
+        const requestBodyStr = serializeUndiciRequestBody(opts || {})
         const requestMeta = { traceId, spanId: (traceCtx && traceCtx.spanId) || null, parentSpanId: (traceCtx && traceCtx.parentSpanId) || null, requestId: (traceCtx && traceCtx.requestId) || null, method: methodStr, url: urlStr }
+        if (requestBodyStr != null) requestMeta.requestBody = requestBodyStr
         if (markSource) markSource(requestMeta, 'http-client')
         const start = require('perf_hooks').performance.now()
         const skipLog = isLoggerUrl(urlStr)
         if (HTTP_CLIENT_MODE !== 'off' && !skipLog) send('info', `[REQUEST] ${methodStr} ${urlStr}`, requestMeta)
         const wrappedCb = typeof callback === 'function' ? function (err, data) {
           const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
-          if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
-            if (err) send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
-            else if (data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+          if (err) {
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+              send('error', `[RESPONSE] ${methodStr} ${urlStr} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+            }
+            return callback(err, data)
           }
-          return callback(err, data)
+          if (!data) return callback(err, data)
+          restoreUndiciResponseBodyAfterReadForLog(data).then(({ logStr, data: restored }) => {
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+              const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+              if (logStr != null) meta.responseBody = logStr
+              send('info', `[RESPONSE] ${methodStr} ${urlStr} ${restored.statusCode} ${duration}ms`, meta)
+            }
+            return callback(null, restored)
+          }).catch(() => {
+            if (HTTP_CLIENT_MODE !== 'off' && !skipLog) {
+              send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+            }
+            return callback(null, data)
+          })
         } : undefined
         const ret = wrappedCb ? origReq.call(this, opts, wrappedCb) : origReq.call(this, opts)
         if (ret && typeof ret.then === 'function' && !wrappedCb) {
           return ret.then(
-            (data) => {
+            async (data) => {
               const duration = Number((require('perf_hooks').performance.now() - start).toFixed(2))
-              if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) send('info', `[RESPONSE] ${methodStr} ${urlStr} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+              if (HTTP_CLIENT_MODE !== 'off' && !skipLog && data) {
+                const { logStr, data: restored } = await restoreUndiciResponseBodyAfterReadForLog(data)
+                const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+                if (logStr != null) meta.responseBody = logStr
+                send('info', `[RESPONSE] ${methodStr} ${urlStr} ${restored.statusCode} ${duration}ms`, meta)
+                return restored
+              }
               return data
             },
             (err) => {
@@ -608,14 +763,12 @@ try {
             const RequestHandler = mod.exports.RequestHandler
             mod.exports = function wrappedApiRequest(opts, callback) {
               const methodStr = String((opts && opts.method) || 'GET').toUpperCase()
-              const urlPart = (opts && opts.origin) ? String(opts.origin).slice(0, 80) : (opts && opts.path) || ''
+              const urlStr = resolveUrlStrFromDispatcherOpts(opts)
+              const urlPart = urlStr !== 'unknown' ? urlStr.slice(0, 80) : ((opts && opts.origin) ? String(opts.origin).slice(0, 80) : (opts && opts.path) || '')
               if (HTTP_DEBUG) try { process.stderr.write('[AZIFY-PATCH] api-request ' + methodStr + ' ' + urlPart + '\n') } catch (_) {}
               if (HTTP_VERBOSE || HTTP_DEBUG) {
                 try { process.stderr.write('[AZIFY] HTTP wrapper api-request ' + methodStr + ' ' + urlPart + '\n') } catch (_) {}
               }
-              const origin = (opts && opts.origin) || ''
-              const pathPart = (opts && opts.path) != null ? opts.path : '/'
-              const urlStr = origin ? (origin + (pathPart.startsWith('/') ? pathPart : '/' + pathPart)) : 'unknown'
               httpLog('WRAPPER api-request ' + methodStr + ' ' + urlStr.slice(0, 80))
               const ctx = getRequestContext() || getLastJobContext()
               const otelCtx = getOtelTraceContext()
@@ -692,6 +845,7 @@ try {
   function patchGlobalFetch() {
     try {
       if (typeof globalThis.fetch !== 'function') return
+      if (globalThis.fetch.__azifyLoggerFetchPatched) return
       if (globalThis.fetch.__azifyPatched) return
       const deps = loadStoreAndSampling()
       if (!deps || deps.HTTP_CLIENT_MODE === 'off') return

package/register.js

@@ -10,7 +10,12 @@ try {
   }
   const ModuleForRequire = require('module')
   const nodeRequireOriginal = ModuleForRequire.prototype.require
-  const bunyan = require('bunyan')
+  let bunyan = null
+  try {
+    bunyan = require('bunyan')
+  } catch (_) {
+    /* bunyan é opcional; sem ele o patch Bunyan não aplica, mas HTTP/Pino/axios devem continuar */
+  }
   const createBunyanStream = require('./streams/bunyan')
   const { createHttpLoggerTransport } = require('./streams/httpQueue')
   const { getRequestContext } = require('./store')
@@ -145,12 +150,34 @@ try {
 
   const debug = process.env.AZIFY_LOGGER_DEBUG === '1'
   const httpVerbose = process.env.AZIFY_LOGGER_HTTP_VERBOSE === '1'
+
+  function extractUrlFromReqResMessage(msgStr) {
+    const s = String(msgStr)
+    const m1 = s.match(/\[(?:REQUEST|RESPONSE)\]\s+\S+\s+(https?:\/\/\S+)/i)
+    if (m1) return m1[1].replace(/[)\]}>.,;]+$/, '')
+    const m2 = s.match(/\[(?:REQUEST|RESPONSE)\]\s+\S+\s+(\S+)/i)
+    if (m2 && /^https?:\/\//i.test(m2[1])) return m2[1].replace(/[)\]}>.,;]+$/, '')
+    return null
+  }
+
+  const OPAQUE_NO_URL = 'https://opaque.invalid/azify-logger-no-url'
+
   function sendOutboundLog(level, message, meta) {
     try {
       const msgStr = String(message)
       const isReqRes = msgStr.includes('[REQUEST]') || msgStr.includes('[RESPONSE]')
+      if (isReqRes && meta && typeof meta === 'object') {
+        const u = meta.url
+        const badUrl =
+          u === 'unknown' ||
+          !String(u || '').trim() ||
+          String(u).toLowerCase() === 'unknown'
+        if (badUrl) {
+          const fromMsg = extractUrlFromReqResMessage(msgStr)
+          meta = fromMsg ? { ...meta, url: fromMsg } : { ...meta, url: OPAQUE_NO_URL }
+        }
+      }
       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 (_) {}
@@ -350,9 +377,16 @@ try {
 
     try {
       const target = new URL(candidate, normalizedLoggerOrigin)
-      const targetOrigin = `${target.protocol}//${target.host}`
+      if (loggerEndpoint.hostname.toLowerCase() !== target.hostname.toLowerCase()) {
+        return false
+      }
+      const portLogger = loggerEndpoint.port || (loggerEndpoint.protocol === 'https:' ? '443' : '80')
+      const portTarget = target.port || (target.protocol === 'https:' ? '443' : '80')
+      if (String(portLogger) !== String(portTarget)) {
+        return false
+      }
       const targetPath = normalizePath(target.pathname)
-      return targetOrigin === normalizedLoggerOrigin && targetPath === normalizedLoggerPath
+      return targetPath === normalizedLoggerPath || targetPath.startsWith(normalizedLoggerPath + '/')
     } catch (_) {
       if (typeof candidate === 'string') {
         const relativePath = normalizePath(candidate)
@@ -363,22 +397,24 @@ try {
     return false
   }
 
-  const originalCreate = bunyan.createLogger
-  bunyan.createLogger = function patchedCreateLogger(options) {
-    const logger = originalCreate.call(bunyan, options)
-    try {
-      const level = process.env.AZIFY_LOG_LEVEL || (options && options.level) || 'info'
-      const loggerUrl = process.env.AZIFY_LOGGER_URL
-      const serviceName = process.env.APP_NAME || (options && options.name)
-      const environment = process.env.NODE_ENV
-
-      logger.addStream({
-        level,
-        type: 'raw',
-        stream: createBunyanStream({ loggerUrl, serviceName, environment })
-      })
-    } catch (_) {}
-    return logger
+  if (bunyan && typeof bunyan.createLogger === 'function') {
+    const originalCreate = bunyan.createLogger
+    bunyan.createLogger = function patchedCreateLogger(options) {
+      const logger = originalCreate.call(bunyan, options)
+      try {
+        const level = process.env.AZIFY_LOG_LEVEL || (options && options.level) || 'info'
+        const loggerUrl = process.env.AZIFY_LOGGER_URL
+        const serviceName = process.env.APP_NAME || (options && options.name)
+        const environment = process.env.NODE_ENV
+
+        logger.addStream({
+          level,
+          type: 'raw',
+          stream: createBunyanStream({ loggerUrl, serviceName, environment })
+        })
+      } catch (_) {}
+      return logger
+    }
   }
 
   const getOtelTraceContext = () => {
@@ -409,16 +445,24 @@ try {
     const { randomBytes } = require('crypto')
     const { performance } = require('perf_hooks')
     const { getRequestContext, getLastJobContext, toTraceIdHex } = require('./store')
+    const {
+      resolveUndiciRequestOpts,
+      serializeUndiciRequestBody,
+      restoreUndiciResponseBodyAfterReadForLog
+    } = require('./utils/undiciLogBodies')
     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 reqOpts = resolveUndiciRequestOpts(url, options)
+      const method = (reqOpts.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 requestBodyStr = serializeUndiciRequestBody(reqOpts)
       const requestMeta = { traceId, spanId: traceCtx?.spanId || null, parentSpanId: traceCtx?.parentSpanId || null, requestId: traceCtx?.requestId || null, method, url: urlString }
+      if (requestBodyStr != null) requestMeta.requestBody = requestBodyStr
       markSource(requestMeta, 'http-client')
       const startTime = performance.now()
       if (HTTP_CLIENT_MODE !== 'off') {
@@ -426,20 +470,39 @@ try {
       }
       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 })
+        if (err) {
+          if (HTTP_CLIENT_MODE !== 'off') {
+            sendOutboundLog('error', `[RESPONSE] ${method} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+          }
+          return callback(err, data)
         }
-        return callback(err, data)
+        if (!data) return callback(err, data)
+        restoreUndiciResponseBodyAfterReadForLog(data).then(({ logStr, data: restored }) => {
+          if (HTTP_CLIENT_MODE !== 'off') {
+            const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+            if (logStr != null) meta.responseBody = logStr
+            sendOutboundLog('info', `[RESPONSE] ${method} ${urlString} ${restored.statusCode} ${duration}ms`, meta)
+          }
+          return callback(null, restored)
+        }).catch(() => {
+          if (HTTP_CLIENT_MODE !== 'off') {
+            sendOutboundLog('info', `[RESPONSE] ${method} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+          }
+          return callback(null, 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) => {
+          async (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 })
+              const { logStr, data: restored } = await restoreUndiciResponseBodyAfterReadForLog(data)
+              const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+              if (logStr != null) meta.responseBody = logStr
+              sendOutboundLog('info', `[RESPONSE] ${method} ${urlString} ${restored.statusCode} ${duration}ms`, meta)
+              return restored
             }
             return data
           },
@@ -468,7 +531,9 @@ try {
         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 requestBodyStr = serializeUndiciRequestBody(opts || {})
         const requestMeta = { traceId, spanId: traceCtx?.spanId || null, parentSpanId: traceCtx?.parentSpanId || null, requestId: traceCtx?.requestId || null, method: methodStr, url: urlString }
+        if (requestBodyStr != null) requestMeta.requestBody = requestBodyStr
         markSource(requestMeta, 'http-client')
         const startTime = performance.now()
         if (HTTP_CLIENT_MODE !== 'off') {
@@ -476,19 +541,38 @@ try {
         }
         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 })
+          if (err) {
+            if (HTTP_CLIENT_MODE !== 'off') {
+              sendOutboundLog('error', `[RESPONSE] ${methodStr} ${urlString} ERROR ${duration}ms`, { ...requestMeta, error: err && err.message, responseTimeMs: duration })
+            }
+            return callback(err, data)
           }
-          return callback(err, data)
+          if (!data) return callback(err, data)
+          restoreUndiciResponseBodyAfterReadForLog(data).then(({ logStr, data: restored }) => {
+            if (HTTP_CLIENT_MODE !== 'off') {
+              const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+              if (logStr != null) meta.responseBody = logStr
+              sendOutboundLog('info', `[RESPONSE] ${methodStr} ${urlString} ${restored.statusCode} ${duration}ms`, meta)
+            }
+            return callback(null, restored)
+          }).catch(() => {
+            if (HTTP_CLIENT_MODE !== 'off') {
+              sendOutboundLog('info', `[RESPONSE] ${methodStr} ${urlString} ${data.statusCode} ${duration}ms`, { ...requestMeta, statusCode: data.statusCode, responseTimeMs: duration })
+            }
+            return callback(null, 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) => {
+            async (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 })
+                const { logStr, data: restored } = await restoreUndiciResponseBodyAfterReadForLog(data)
+                const meta = { ...requestMeta, statusCode: restored.statusCode, responseTimeMs: duration }
+                if (logStr != null) meta.responseBody = logStr
+                sendOutboundLog('info', `[RESPONSE] ${methodStr} ${urlString} ${restored.statusCode} ${duration}ms`, meta)
+                return restored
               }
               return data
             },
@@ -1552,6 +1636,35 @@ try {
         return url
       }
 
+      const MAX_HTTP_BODY_CHARS = Math.min(
+        Math.max(parseInt(String(process.env.AZIFY_LOGGER_HTTP_BODY_MAX_CHARS || '5000'), 10) || 5000, 100),
+        100000
+      )
+      function clipHttpLogString(s) {
+        if (typeof s !== 'string') return s
+        return s.length > MAX_HTTP_BODY_CHARS ? s.slice(0, MAX_HTTP_BODY_CHARS) : s
+      }
+      function stringifyHttpBodyForLog(value) {
+        if (value == null) return null
+        try {
+          if (typeof value === 'string') {
+            return clipHttpLogString(value)
+          }
+          if (Buffer.isBuffer(value)) {
+            return clipHttpLogString(value.toString('utf8'))
+          }
+          if (value && typeof value.pipe === 'function') {
+            return '[Stream]'
+          }
+          if (typeof value === 'object') {
+            return clipHttpLogString(JSON.stringify(value))
+          }
+          return clipHttpLogString(String(value))
+        } catch (_) {
+          return '[unserializable]'
+        }
+      }
+
       const patchInstance = (instance) => {
         if (instance.__azifyLoggerPatched) {
           return instance
@@ -1595,6 +1708,11 @@ try {
               headers: config.headers
             }
 
+            const requestBodyString = stringifyHttpBodyForLog(config.data)
+            if (requestBodyString != null) {
+              requestMeta.requestBody = requestBodyString
+            }
+
             markSource(requestMeta, 'http-client')
             config.__azifyLogger = {
               meta: requestMeta,
@@ -1648,12 +1766,15 @@ try {
 
                 const stringifyBody = (value) => {
                   if (value == null) return null
-                  if (typeof value === 'string') return value
+                  if (typeof value === 'string') return clipHttpLogString(value)
+                  if (Buffer.isBuffer(value)) {
+                    return clipHttpLogString(value.toString('utf8'))
+                  }
                   try {
-                    return JSON.stringify(value)
+                    return clipHttpLogString(JSON.stringify(value))
                   } catch (_) {
                     try {
-                      return String(value)
+                      return clipHttpLogString(String(value))
                     } catch (_) {
                       return null
                     }
@@ -1662,17 +1783,16 @@ try {
 
                 if (marker && marker.meta) {
                   duration = Number((performance.now() - marker.start).toFixed(2))
-                  let responseBodyString = stringifyBody(response.data)
-                  if (typeof responseBodyString === 'string' && responseBodyString.length > 5000) {
-                    responseBodyString = responseBodyString.slice(0, 5000)
-                  }
+                  const responseBodyString = stringifyBody(response.data)
                   meta = {
                     ...marker.meta,
                     url: finalUrl,
                     statusCode: response.status,
                     responseTimeMs: duration,
-                    responseHeaders: response.headers,
-                    responseBody: responseBodyString
+                    responseHeaders: response.headers
+                  }
+                  if (responseBodyString != null) {
+                    meta.responseBody = responseBodyString
                   }
                 } else {
                   const requestHeaders = response.config?.headers || {}
@@ -1681,10 +1801,7 @@ try {
                   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()
-                  let responseBodyString = stringifyBody(response.data)
-                  if (typeof responseBodyString === 'string' && responseBodyString.length > 5000) {
-                    responseBodyString = responseBodyString.slice(0, 5000)
-                  }
+                  const responseBodyString = stringifyBody(response.data)
 
                   meta = {
                     traceId,
@@ -1695,8 +1812,10 @@ try {
                     url: finalUrl,
                     statusCode: response.status,
                     responseTimeMs: duration,
-                    responseHeaders: response.headers,
-                    responseBody: responseBodyString
+                    responseHeaders: response.headers
+                  }
+                  if (responseBodyString != null) {
+                    meta.responseBody = responseBodyString
                   }
                 }
 
@@ -1895,19 +2014,35 @@ try {
           } catch (_) {
           }
 
+          const maxFetchBodyChars = Math.min(
+            Math.max(parseInt(String(process.env.AZIFY_LOGGER_HTTP_BODY_MAX_CHARS || '5000'), 10) || 5000, 100),
+            100000
+          )
+          const clipFetchBody = (s) => {
+            if (typeof s !== 'string' || !s.length) return null
+            return s.length > maxFetchBodyChars ? s.slice(0, maxFetchBodyChars) : s
+          }
+
           let requestBodyString = null
-          if (init && init.body !== null && init.body !== undefined) {
-            try {
+          try {
+            if (init && init.body !== null && init.body !== undefined) {
               if (typeof init.body === 'string') {
-                requestBodyString = init.body
+                requestBodyString = clipFetchBody(init.body)
               } else if (init.body instanceof FormData || init.body instanceof URLSearchParams) {
                 requestBodyString = '[FormData/URLSearchParams]'
-              } else if (typeof init.body === 'object' && !(init.body instanceof Blob) && !(init.body instanceof ArrayBuffer)) {
-                try {
-                  requestBodyString = JSON.stringify(init.body)
-                } catch (_) {
-                  requestBodyString = String(init.body)
-                }
+              }
+            }
+          } catch (_) {
+          }
+          if (requestBodyString == null && request.body != null && method !== 'GET' && method !== 'HEAD') {
+            try {
+              const clone = request.clone()
+              const text = await Promise.race([
+                clone.text(),
+                new Promise((resolve) => setTimeout(() => resolve(null), 4000))
+              ])
+              if (typeof text === 'string' && text.length) {
+                requestBodyString = clipFetchBody(text)
               }
             } catch (_) {
             }
@@ -2014,10 +2149,15 @@ try {
                 }
               }
 
+              const responseReadMs = Math.min(
+                Math.max(parseInt(String(process.env.AZIFY_LOGGER_HTTP_RESPONSE_READ_MS || '4000'), 10) || 4000, 200),
+                30000
+              )
+
               if (contentType.includes('application/json') || contentType.includes('text/')) {
                 try {
                   const clonedResponse = response.clone()
-                  const bodyText = await readBodyWithTimeout(clonedResponse, 200)
+                  const bodyText = await readBodyWithTimeout(clonedResponse, responseReadMs)
                   if (bodyText) {
                     if (contentType.includes('application/json')) {
                       try {
@@ -2028,13 +2168,13 @@ try {
                     } else {
                       responseBodyString = bodyText
                     }
-                    if (typeof responseBodyString === 'string' && responseBodyString.length > 5000) {
-                      responseBodyString = responseBodyString.slice(0, 5000)
+                    if (typeof responseBodyString === 'string' && responseBodyString.length > maxFetchBodyChars) {
+                      responseBodyString = responseBodyString.slice(0, maxFetchBodyChars)
                     }
                   }
                 } catch (_) {
                   try {
-                    const bodyText = await readBodyWithTimeout(response, 200)
+                    const bodyText = await readBodyWithTimeout(response, responseReadMs)
                     if (bodyText) {
                       if (contentType.includes('application/json')) {
                         try {
@@ -2045,13 +2185,23 @@ try {
                       } else {
                         responseBodyString = bodyText
                       }
-                      if (typeof responseBodyString === 'string' && responseBodyString.length > 5000) {
-                        responseBodyString = responseBodyString.slice(0, 5000)
+                      if (typeof responseBodyString === 'string' && responseBodyString.length > maxFetchBodyChars) {
+                        responseBodyString = responseBodyString.slice(0, maxFetchBodyChars)
                       }
                     }
                   } catch (_) {
                   }
                 }
+              } else if (response.status !== 204 && response.status !== 205 && response.status !== 304) {
+                try {
+                  const clonedResponse = response.clone()
+                  const bodyText = await readBodyWithTimeout(clonedResponse, responseReadMs)
+                  if (bodyText && bodyText.length) {
+                    responseBodyString =
+                      bodyText.length > maxFetchBodyChars ? bodyText.slice(0, maxFetchBodyChars) : bodyText
+                  }
+                } catch (_) {
+                }
               }
             } catch (_) {
             }

package/scripts/redis-worker.js

@@ -254,6 +254,9 @@ function sanitizePayload(payload) {
     if (sanitized.meta.responseBody) {
       sanitized.meta.responseBody = sanitizeBody(sanitized.meta.responseBody)
     }
+    if (sanitized.meta.requestBody) {
+      sanitized.meta.requestBody = sanitizeBody(sanitized.meta.requestBody)
+    }
   }
   
   return sanitized

package/server.js

@@ -186,7 +186,11 @@ async function ensureIndexTemplate() {
           settings: {
             number_of_shards: 1,
           number_of_replicas: 0,
-          'index.refresh_interval': '5s'
+          'index.refresh_interval': '5s',
+          'index.mapping.total_fields.limit': Math.min(
+            Math.max(Number(process.env.AZIFY_LOGGER_OPENSEARCH_TOTAL_FIELDS_LIMIT) || 5000, 1000),
+            20000
+          )
           },
           mappings: {
             properties: {
@@ -2327,14 +2331,22 @@ function _drainOpenSearchQueue() {
             if (_openSearchCircuitRetryTimer.unref) _openSearchCircuitRetryTimer.unref()
           }
         }
-        if (_openSearchFailuresInRow <= 2) {
-          const status = error?.response?.status
-          const errorMsg = error?.response?.data?.error?.reason ||
-            error?.response?.data?.message ||
-            error?.message ||
-            'Erro desconhecido'
-          console.error('❌ Falha ao enviar log para OpenSearch', { status, message: errorMsg })
-          if (error?.code) console.error('⚙️  Código de erro:', error.code)
+        const status = error?.response?.status
+        const rawMsg = error?.response?.data?.error?.reason ||
+          error?.response?.data?.error?.type ||
+          error?.response?.data?.message ||
+          error?.message ||
+          'Erro desconhecido'
+        const errorMsg = typeof rawMsg === 'string' ? rawMsg.slice(0, 800) : String(rawMsg).slice(0, 800)
+        const logPayload = {
+          index: job.indexName,
+          serviceName: job.serviceName,
+          status,
+          message: errorMsg
+        }
+        console.error('❌ Falha ao enviar log para OpenSearch', logPayload)
+        if (error?.code && _openSearchFailuresInRow <= 10) {
+          console.error('⚙️  Código de erro:', error.code)
         }
       })
       .finally(() => {

package/utils/undiciLogBodies.js

@@ -0,0 +1,83 @@
+'use strict'
+
+function maxBodyChars() {
+  return Math.min(
+    Math.max(parseInt(String(process.env.AZIFY_LOGGER_HTTP_BODY_MAX_CHARS || '5000'), 10) || 5000, 100),
+    100000
+  )
+}
+
+function clip(s) {
+  const m = maxBodyChars()
+  if (typeof s !== 'string' || !s.length) return null
+  return s.length > m ? s.slice(0, m) : s
+}
+
+/** undici: request(url, opts) ou request(opts) — retorna o objeto de opções com body/method. */
+function resolveUndiciRequestOpts(url, options) {
+  if (typeof url === 'object' && url !== null && !(url instanceof URL)) {
+    return url
+  }
+  return options && typeof options === 'object' ? options : {}
+}
+
+function serializeUndiciRequestBody(opts) {
+  if (!opts || opts.body == null || opts.body === undefined) return null
+  try {
+    if (typeof opts.body === 'string') return clip(opts.body)
+    if (Buffer.isBuffer(opts.body)) return clip(opts.body.toString('utf8'))
+    if (opts.body && typeof opts.body.pipe === 'function') return '[Stream]'
+    return clip(String(opts.body))
+  } catch (_) {
+    return null
+  }
+}
+
+function responseReadTimeoutMs() {
+  return Math.min(
+    Math.max(parseInt(String(process.env.AZIFY_LOGGER_HTTP_RESPONSE_READ_MS || '4000'), 10) || 4000, 200),
+    30000
+  )
+}
+
+/**
+ * Lê o body da resposta undici para log e substitui `data.body` por um objeto com .text()/.json()
+ * compatível com o que o undici expõe, para o chamador ainda conseguir fazer parse.
+ */
+async function restoreUndiciResponseBodyAfterReadForLog(data) {
+  if (!data || !data.body || typeof data.body.text !== 'function') {
+    return { logStr: null, data }
+  }
+  const timeoutMs = responseReadTimeoutMs()
+  try {
+    const text = await Promise.race([
+      data.body.text(),
+      new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeoutMs))
+    ])
+    if (text == null || typeof text !== 'string') {
+      return { logStr: null, data }
+    }
+    const logStr = clip(text)
+    data.body = {
+      async text() {
+        return text
+      },
+      async json() {
+        return JSON.parse(text)
+      },
+      async arrayBuffer() {
+        return Buffer.from(text, 'utf8').buffer
+      }
+    }
+    return { logStr, data }
+  } catch (_) {
+    return { logStr: null, data }
+  }
+}
+
+module.exports = {
+  resolveUndiciRequestOpts,
+  serializeUndiciRequestBody,
+  restoreUndiciResponseBodyAfterReadForLog,
+  maxBodyChars
+}