azify-logger 1.0.55-test → 1.0.55-test-1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.55-test",
+  "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 {
@@ -199,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) => {
@@ -244,25 +273,48 @@ 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 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) => {
@@ -323,25 +375,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) => {
@@ -401,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) => {

package/register.js

@@ -445,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') {
@@ -462,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
           },
@@ -504,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') {
@@ -512,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
             },
@@ -1966,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 (_) {
             }
@@ -2085,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 {
@@ -2099,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 {
@@ -2116,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/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
+}