azify-logger 1.0.55 → 1.0.57

package/register.js

@@ -25,6 +25,7 @@ try {
   const os = require('os')
 
   const { shouldSample, markSource, HTTP_CLIENT_MODE } = require('./sampling')
+  const { sanitizeOutboundHttpMetaBodies } = require('./utils/sanitizeSensitiveHttpBody')
 
   if (process.env.AZIFY_LOGGER_DEBUG === '1') {
     try { process.stderr.write('[azify-logger] REGISTER step1b after requires\n') } catch (_) {}
@@ -32,13 +33,17 @@ try {
   }
   const serviceName = process.env.APP_NAME
   const environment = process.env.NODE_ENV
-  const loggerUrlFromEnv = process.env.AZIFY_LOGGER_URL
-
+  const loggerUrlRaw = (process.env.AZIFY_LOGGER_URL || '').trim()
+  if (!loggerUrlRaw) {
+    process.stderr.write('[azify-logger] AZIFY_LOGGER_URL não está definida.\n')
+    throw new Error('AZIFY_LOGGER_URL is required')
+  }
   let loggerEndpoint
   try {
-    loggerEndpoint = new URL(loggerUrlFromEnv)
-  } catch (_) {
-    loggerEndpoint = new URL('http://localhost:3001/log')
+    loggerEndpoint = new URL(loggerUrlRaw)
+  } catch (urlErr) {
+    process.stderr.write(`[azify-logger] AZIFY_LOGGER_URL inválida: ${loggerUrlRaw} (${urlErr.message})\n`)
+    throw urlErr
   }
 
   const loggerUrlString = loggerEndpoint.toString()
@@ -176,6 +181,9 @@ try {
           const fromMsg = extractUrlFromReqResMessage(msgStr)
           meta = fromMsg ? { ...meta, url: fromMsg } : { ...meta, url: OPAQUE_NO_URL }
         }
+        try {
+          meta = sanitizeOutboundHttpMetaBodies(meta)
+        } catch (_) {}
       }
       if (isReqRes && meta && meta.url && isLoggerApiCall({ url: meta.url })) return
       const source = meta && meta.__source
@@ -445,16 +453,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 +478,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 +539,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 +549,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
             },
@@ -1588,6 +1644,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
@@ -1631,6 +1716,11 @@ try {
               headers: config.headers
             }
 
+            const requestBodyString = stringifyHttpBodyForLog(config.data)
+            if (requestBodyString != null) {
+              requestMeta.requestBody = requestBodyString
+            }
+
             markSource(requestMeta, 'http-client')
             config.__azifyLogger = {
               meta: requestMeta,
@@ -1684,12 +1774,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
                     }
@@ -1698,17 +1791,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 || {}
@@ -1717,10 +1809,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,
@@ -1731,8 +1820,10 @@ try {
                     url: finalUrl,
                     statusCode: response.status,
                     responseTimeMs: duration,
-                    responseHeaders: response.headers,
-                    responseBody: responseBodyString
+                    responseHeaders: response.headers
+                  }
+                  if (responseBodyString != null) {
+                    meta.responseBody = responseBodyString
                   }
                 }
 
@@ -1931,19 +2022,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 (_) {
             }
@@ -2050,10 +2157,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 {
@@ -2064,13 +2176,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 {
@@ -2081,13 +2193,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

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+const path = require('path')
 const os = require('os')
 const http = require('http')
 const https = require('https')
@@ -159,24 +160,6 @@ const SENSITIVE_HEADER_KEYS = new Set([
   'x-timestamp'
 ])
 
-const SENSITIVE_BODY_FIELDS = new Set([
-  'password',
-  'token',
-  'secret',
-  'apiKey',
-  'api_key',
-  'accessToken',
-  'access_token',
-  'refreshToken',
-  'refresh_token',
-  'clientSecret',
-  'client_secret',
-  'creditCard',
-  'credit_card',
-  'cvv',
-  'cvc'
-])
-
 function sanitizeHeaders(headers) {
   if (!headers || typeof headers !== 'object') {
     return {}
@@ -195,31 +178,10 @@ function sanitizeHeaders(headers) {
   return sanitized
 }
 
+const sanitizeBodyJsonValue = require(path.join(__dirname, '..', 'utils', 'sanitizeSensitiveHttpBody')).sanitizeBodyJsonValue
+
 function sanitizeBody(body) {
-  if (!body || typeof body !== 'object') {
-    return body
-  }
-  
-  try {
-    const sanitized = Array.isArray(body) ? [] : {}
-    
-    for (const key in body) {
-      if (!body.hasOwnProperty(key)) continue
-      const lower = String(key).toLowerCase()
-      
-      if (SENSITIVE_BODY_FIELDS.has(lower) || lower.includes('password') || lower.includes('secret')) {
-        sanitized[key] = '***'
-      } else if (typeof body[key] === 'object' && body[key] !== null) {
-        sanitized[key] = sanitizeBody(body[key])
-      } else {
-        sanitized[key] = body[key]
-      }
-    }
-    
-    return sanitized
-  } catch (err) {
-    return body
-  }
+  return sanitizeBodyJsonValue(body)
 }
 
 function sanitizePayload(payload) {
@@ -254,6 +216,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