azify-logger 1.0.34 → 1.0.36

package/middleware-express.js

@@ -210,10 +210,6 @@ function createExpressLoggingMiddleware(options = {}) {
     
     const ctx = ensureRequestContext()
     
-    runWithRequestContext(ctx, () => {
-      next()
-    })
-    
     const logWithContext = (level, message, meta) => {
       const otelCtx = getOtelTraceContext()
       const ctx = getRequestContext() || ensureRequestContext()
@@ -284,8 +280,10 @@ function createExpressLoggingMiddleware(options = {}) {
         }
         if (query) request.query = query
         if (config.captureHeaders && cachedHeaders) request.headers = cachedHeaders
+        let requestBody = null
         if (config.captureRequestBody && req.body !== undefined && req.body != null) {
-          request.body = safeSerializeBody(req.body)
+          requestBody = safeSerializeBody(req.body)
+          request.body = requestBody
         }
         
         const meta = {
@@ -294,18 +292,10 @@ function createExpressLoggingMiddleware(options = {}) {
           parentSpanId: reqCtx.parentSpanId || null,
           requestId,
           request,
+          requestBody,
           timestamp: Date.now(),
           hostname
         }
-        
-        if (config.captureRequestBody && req.body !== undefined && req.body != null) {
-          const serializedBody = safeSerializeBody(req.body)
-          if (typeof serializedBody === 'string') {
-            meta.requestBody = serializedBody
-          } else {
-            meta.requestBody = JSON.stringify(serializedBody)
-          }
-        }
         if (serviceObj) meta.service = serviceObj
         if (config.environment) meta.environment = config.environment
         
@@ -316,11 +306,6 @@ function createExpressLoggingMiddleware(options = {}) {
     const originalEnd = res.end.bind(res)
     
     res.end = (chunk, encoding) => {
-      if (logSent) {
-        return originalEnd(chunk, encoding)
-      }
-      logSent = true
-      
       const result = originalEnd(chunk, encoding)
 
       if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
@@ -328,46 +313,84 @@ function createExpressLoggingMiddleware(options = {}) {
         responseChunkCaptured = true
       }
       
-      process.nextTick(() => {
-        ensureIds()
-        
-        const statusCode = res.statusCode || 200
-        const duration = Date.now() - startTime
-        const response = { statusCode, durationMs: duration }
-        
-        if (config.captureHeaders) {
-          ensureHeaders()
-        }
-        
-        const requestObj = {
-          id: requestId,
-          method,
-          url,
-          path,
-          ip: clientIp
-        }
-        if (query) requestObj.query = query
-        if (config.captureHeaders && cachedHeaders) requestObj.headers = cachedHeaders
+      if (!logSent) {
+        logSent = true
         
-        const meta = {
-          traceId: reqCtx.traceId,
-          spanId: reqCtx.spanId,
-          parentSpanId: reqCtx.parentSpanId || null,
-          requestId,
-          request: requestObj,
-          response,
-          timestamp: Date.now(),
-          hostname
-        }
-        if (serviceObj) meta.service = serviceObj
-        if (config.environment) meta.environment = config.environment
-        
-        const chunkToProcess = (responseChunk !== null && responseChunkCaptured) ? responseChunk : null
-        emitResponseLog(meta, chunkToProcess)
-      })
+        process.nextTick(() => {
+          try {
+            ensureIds()
+            
+            const statusCode = res.statusCode || 200
+            const duration = Date.now() - startTime
+            const response = { statusCode, durationMs: duration }
+            
+            if (config.captureHeaders) {
+              ensureHeaders()
+            }
+            
+            const requestObj = {
+              id: requestId,
+              method,
+              url,
+              path,
+              ip: clientIp
+            }
+            if (query) requestObj.query = query
+            if (config.captureHeaders && cachedHeaders) requestObj.headers = cachedHeaders
+            
+            const meta = {
+              traceId: reqCtx.traceId,
+              spanId: reqCtx.spanId,
+              parentSpanId: reqCtx.parentSpanId || null,
+              requestId,
+              request: requestObj,
+              response,
+              timestamp: Date.now(),
+              hostname
+            }
+            if (serviceObj) meta.service = serviceObj
+            if (config.environment) meta.environment = config.environment
+            
+            const chunkToProcess = (responseChunk !== null && responseChunkCaptured) ? responseChunk : null
+            emitResponseLog(meta, chunkToProcess)
+          } catch (err) {
+            try {
+              ensureIds()
+              const statusCode = res.statusCode || 200
+              const duration = Date.now() - startTime
+              const response = { statusCode, durationMs: duration }
+              const requestObj = {
+                id: requestId,
+                method,
+                url,
+                path,
+                ip: clientIp || 'unknown'
+              }
+              const meta = {
+                traceId: reqCtx?.traceId || traceId,
+                spanId: reqCtx?.spanId || spanId,
+                parentSpanId: reqCtx?.parentSpanId || parentSpanId || null,
+                requestId: requestId || fastUUID(),
+                request: requestObj,
+                response,
+                timestamp: Date.now(),
+                hostname
+              }
+              if (serviceObj) meta.service = serviceObj
+              if (config.environment) meta.environment = config.environment
+              emitResponseLog(meta, null)
+            } catch (_) {
+            }
+          }
+        })
+      }
       
       return result
     }
+
+    runWithRequestContext(ctx, () => {
+      next()
+    })
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -21,7 +21,7 @@
     "validate:retention": "node scripts/validate-retention.js",
     "inspect:zip": "node scripts/inspect-zip.js",
     "retention": "node scripts/retention-manager.js",
-    "list:blob": "node scripts/list-blob-files.js",
+    "list:blob": "bash -c 'set -a && source env/app.env && set +a && node scripts/list-blob-files.js'",
     "list:blob:recent": "node scripts/download-blob-zip.js",
     "check:old-logs": "node scripts/check-old-logs.js",
     "validate:blob": "node scripts/validate-blob-zip.js",

package/register.js

@@ -79,50 +79,34 @@ try {
   }
 
   function sendOutboundLog(level, message, meta) {
-    const source = meta && meta.__source
-    if (!shouldSample(level, source)) {
-      return
-    }
-
-    const metaCopy = { ...meta }
-    if (metaCopy.requestBody != null) {
-      if (typeof metaCopy.requestBody !== 'string') {
-        try {
-          metaCopy.requestBody = JSON.stringify(metaCopy.requestBody)
-        } catch (_) {
-          metaCopy.requestBody = String(metaCopy.requestBody)
-        }
+    try {
+      const source = meta && meta.__source
+      if (!shouldSample(level, source)) {
+        return
       }
-    }
-    
-    if (metaCopy.meta && metaCopy.meta.requestBody != null) {
-      if (typeof metaCopy.meta.requestBody !== 'string') {
-        try {
-          metaCopy.meta.requestBody = JSON.stringify(metaCopy.meta.requestBody)
-        } catch (_) {
-          metaCopy.meta.requestBody = String(metaCopy.meta.requestBody)
+
+      const payload = {
+        level,
+        message,
+        meta: {
+          ...meta,
+          service: {
+            name: serviceName,
+            version: (meta && meta.service && meta.service.version) || '1.0.0'
+          },
+          environment,
+          timestamp: new Date().toISOString(),
+          hostname: os.hostname()
         }
       }
-    }
 
-    const payload = {
-      level,
-      message,
-      meta: {
-        ...metaCopy,
-        service: {
-          name: serviceName,
-          version: (meta && meta.service && meta.service.version) || '1.0.0'
-        },
-        environment,
-        timestamp: new Date().toISOString(),
-        hostname: os.hostname()
+      if (transport && typeof transport.enqueue === 'function') {
+        transport.enqueue(payload, {
+          'content-type': 'application/json'
+        })
       }
+    } catch (err) {
     }
-
-    transport.enqueue(payload, {
-      'content-type': 'application/json'
-    })
   }
 
   function normalizePath(path) {
@@ -173,6 +157,10 @@ try {
     return logger
   }
 
+  const getOtelTraceContext = () => {
+    return null
+  }
+
   try {
     const Module = require('module')
     const originalRequire = Module.prototype.require
@@ -590,7 +578,12 @@ try {
             const childCtx = { traceId, spanId, parentSpanId, requestId }
             config.__azifyChildCtx = childCtx
 
-            if (HTTP_CLIENT_MODE === 'all') {
+            const shouldLogRequest =
+              HTTP_CLIENT_MODE === 'all' ||
+              HTTP_CLIENT_MODE === 'errors' ||
+              !!traceId
+
+            if (shouldLogRequest) {
               sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
             }
 
@@ -626,16 +619,34 @@ try {
                 if (finalUrl && finalUrl !== 'unknown') {
                 let meta
                 let duration = 0
+
+                const stringifyBody = (value) => {
+                  if (value == null) return null
+                  if (typeof value === 'string') return value
+                  try {
+                    return JSON.stringify(value)
+                  } catch (_) {
+                    try {
+                      return String(value)
+                    } catch (_) {
+                      return null
+                    }
+                  }
+                }
                 
                 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)
+                  }
                   meta = {
                     ...marker.meta,
                     url: finalUrl,
                     statusCode: response.status,
                     responseTimeMs: duration,
                     responseHeaders: response.headers,
-                    responseBody: response.data
+                    responseBody: responseBodyString
                   }
                 } else {
                   const requestHeaders = response.config?.headers || {}
@@ -644,6 +655,10 @@ 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)
+                  }
                   
                   meta = {
                     traceId,
@@ -655,7 +670,7 @@ try {
                     statusCode: response.status,
                     responseTimeMs: duration,
                     responseHeaders: response.headers,
-                    responseBody: response.data
+                    responseBody: responseBodyString
                   }
                 }
                 
@@ -760,7 +775,6 @@ try {
   } catch (_) {}
 
   try {
-
     if (typeof globalThis.fetch === 'function') {
       const g = globalThis
       if (!g.__azifyLoggerFetchPatched) {
@@ -771,10 +785,24 @@ try {
         const originalFetch = globalThis.fetch.bind(globalThis)
 
         function ensureRequest(input, init) {
-          if (typeof Request !== 'undefined' && input instanceof Request) {
-            return init ? new Request(input, init) : input
+          try {
+            if (typeof Request !== 'undefined' && input instanceof Request) {
+              if (init) {
+                return new Request(input, init)
+              }
+              return input
+            }
+            if (init) {
+              return new Request(input, init)
+            }
+            return new Request(input, {})
+          } catch (err) {
+            try {
+              return new Request(input, init || {})
+            } catch (err2) {
+              return new Request(String(input), {})
+            }
           }
-          return new Request(input, init)
         }
 
         globalThis.fetch = async function patchedFetch(input, init) {
@@ -782,60 +810,35 @@ try {
             return originalFetch(input, init)
           }
           
-          let url = 'unknown'
-          let method = 'GET'
+          let request
+          let method = 'UNKNOWN'
+          let url = String(input)
           
-          if (typeof input === 'string') {
-            url = input
-            method = (init?.method || 'GET').toUpperCase()
-          } else if (input instanceof URL) {
-            url = input.toString()
-            method = (init?.method || 'GET').toUpperCase()
-          } else if (typeof Request !== 'undefined' && input instanceof Request) {
-            url = input.url
-            method = input.method.toUpperCase()
-          } else {
+          try {
+            request = ensureRequest(input, init)
+            method = request.method.toUpperCase()
+            url = request.url
+          } catch (err) {
             try {
-              url = String(input)
-              method = (init?.method || 'GET').toUpperCase()
+              const basicMeta = {
+                traceId: randomUUID(),
+                spanId: randomBytes(8).toString('hex'),
+                parentSpanId: null,
+                requestId: randomUUID(),
+                method: (init && init.method) ? String(init.method).toUpperCase() : 'UNKNOWN',
+                url: String(input),
+                headers: {}
+              }
+              markSource(basicMeta, 'http-client')
+              sendOutboundLog('info', `[REQUEST] ${basicMeta.method} ${basicMeta.url}`, basicMeta)
             } catch (_) {
-              return originalFetch(input, init)
             }
+            return originalFetch(input, init)
           }
-          
+
           const testMeta = { url }
           if (isLoggerApiCall(testMeta)) {
-            return originalFetch(input, init)
-          }
-          
-          let requestBody = null
-          if (init && init.body != null) {
-            try {
-              const body = init.body
-              if (typeof body === 'string') {
-                requestBody = body
-              } else if (Buffer.isBuffer(body)) {
-                requestBody = body.toString('utf8')
-              } else if (body instanceof FormData) {
-                requestBody = '[FormData]'
-              } else if (body instanceof URLSearchParams) {
-                requestBody = body.toString()
-              } else if (typeof body === 'object' && body !== null) {
-                requestBody = JSON.stringify(body)
-              } else {
-                requestBody = String(body)
-              }
-            } catch (error) {
-              requestBody = null
-            }
-          } else if (typeof Request !== 'undefined' && input instanceof Request && input.body && !input.bodyUsed) {
-            try {
-              const cloned = input.clone()
-              const text = await cloned.text()
-              requestBody = text
-            } catch (_) {
-              requestBody = null
-            }
+            return originalFetch(request)
           }
 
           const ctx = getRequestContext()
@@ -844,6 +847,32 @@ try {
           const requestId = (ctx?.requestId) || randomUUID()
           const spanId = randomBytes(8).toString('hex')
 
+          try {
+            request.headers.set('x-trace-id', traceId)
+            request.headers.set('x-span-id', spanId)
+            request.headers.set('x-parent-span-id', parentSpanId || '')
+            request.headers.set('x-request-id', requestId)
+          } catch (_) {
+          }
+
+          let requestBodyString = null
+          if (init && init.body !== null && init.body !== undefined) {
+            try {
+              if (typeof init.body === 'string') {
+                requestBodyString = 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 (_) {
+            }
+          }
+
           const requestMeta = {
             traceId,
             spanId,
@@ -854,95 +883,18 @@ try {
             headers: {}
           }
 
-          if (requestBody != null) {
-            let finalRequestBody = requestBody
-            if (typeof requestBody !== 'string') {
-              try {
-                finalRequestBody = JSON.stringify(requestBody)
-              } catch (_) {
-                finalRequestBody = String(requestBody)
-              }
-            }
-            requestMeta.requestBody = finalRequestBody
+          try {
+            requestMeta.headers = Object.fromEntries(request.headers.entries())
+          } catch (_) {
           }
 
-          let request
-          try {
-            let headers
-            if (init?.headers instanceof Headers) {
-              headers = new Headers(init.headers)
-            } else if (init?.headers) {
-              headers = new Headers(init.headers)
-            } else {
-              headers = new Headers()
-            }
-            
-            headers.set('x-trace-id', traceId)
-            headers.set('x-span-id', spanId)
-            headers.set('x-parent-span-id', parentSpanId || '')
-            headers.set('x-request-id', requestId)
-            
-            requestMeta.headers = Object.fromEntries(headers.entries())
-            
-            request = ensureRequest(input, {
-              ...init,
-              headers: headers
-            })
-          } catch (error) {
-            if (init?.headers) {
-              try {
-                requestMeta.headers = typeof init.headers === 'object' && !(init.headers instanceof Headers)
-                  ? init.headers
-                  : Object.fromEntries(new Headers(init.headers).entries())
-              } catch (_) {
-                requestMeta.headers = {}
-              }
-            }
-            
-            request = ensureRequest(input, init)
+          if (requestBodyString !== null) {
+            requestMeta.requestBody = requestBodyString
           }
 
           markSource(requestMeta, 'http-client')
-          const hasTraceHeaders = !!(requestMeta.traceId && requestMeta.spanId)
-          const shouldLogRequest =
-            HTTP_CLIENT_MODE === 'all' ||
-            HTTP_CLIENT_MODE === 'errors' ||
-            hasTraceHeaders
-          
-          let requestWasLogged = false
-
-          if (shouldLogRequest) {
-            const metaCopy = { ...requestMeta }
-            if (metaCopy.requestBody != null && typeof metaCopy.requestBody !== 'string') {
-              try {
-                metaCopy.requestBody = JSON.stringify(metaCopy.requestBody)
-              } catch (_) {
-                metaCopy.requestBody = String(metaCopy.requestBody)
-              }
-            }
-            const payload = {
-              level: 'info',
-              message: `[REQUEST] ${method} ${url}`,
-              meta: {
-                ...metaCopy,
-                service: {
-                  name: serviceName,
-                  version: '1.0.0'
-                },
-                environment,
-                timestamp: new Date().toISOString(),
-                hostname: os.hostname()
-              }
-            }
-            try {
-              transport.enqueue(payload, {
-                'content-type': 'application/json'
-              })
-              requestWasLogged = true
-            } catch (enqueueErr) {
-              sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
-              requestWasLogged = true
-            }
+          if (HTTP_CLIENT_MODE !== 'off') {
+            sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
           }
 
           const childCtx = {
@@ -954,202 +906,134 @@ try {
 
           const start = performance.now()
 
+          let response
           try {
-            const response = await runWithRequestContext(childCtx, function() {
+            response = await runWithRequestContext(childCtx, function() {
               return originalFetch(request)
             })
-
+          } catch (error) {
             const duration = Number((performance.now() - start).toFixed(2))
-            const hasTraceHeaders = !!(requestMeta.traceId && requestMeta.spanId)
-            const wasRequestLogged = requestWasLogged || HTTP_CLIENT_MODE === 'all' || HTTP_CLIENT_MODE === 'errors' || hasTraceHeaders
-            const shouldLogResponse =
-              HTTP_CLIENT_MODE === 'all' ||
-              (HTTP_CLIENT_MODE === 'errors' && (response.status >= 400 || wasRequestLogged)) ||
-              hasTraceHeaders ||
-              requestWasLogged
+            try {
+              const errorMeta = {
+                ...requestMeta,
+                responseTimeMs: duration
+              }
+              markSource(errorMeta, 'http-client')
+              const err = error instanceof Error ? error : new Error(String(error))
+              errorMeta.error = {
+                name: err.name,
+                message: err.message,
+                stack: err.stack
+              }
+              sendOutboundLog('error', `[ERROR] ${method} ${url}`, errorMeta)
+            } catch (_) {
+            }
+            throw error
+          }
+
+          const duration = Number((performance.now() - start).toFixed(2))
+          const shouldLogResponse = HTTP_CLIENT_MODE !== 'off'
 
-            let responseCloneForLogging = null
-            if (shouldLogResponse) {
+          if (shouldLogResponse && response) {
+            const headersToObject = (headers) => {
               try {
-                responseCloneForLogging = response.clone()
-              } catch (cloneError) {
-                responseCloneForLogging = null
+                if (!headers) return {}
+                if (typeof headers.entries === 'function') {
+                  return Object.fromEntries(headers.entries())
+                }
+                if (typeof headers.forEach === 'function') {
+                  const out = {}
+                  headers.forEach((value, key) => {
+                    out[key] = value
+                  })
+                  return out
+                }
+                if (typeof headers === 'object') {
+                  return { ...headers }
+                }
+              } catch (_) {
               }
+              return {}
             }
-
-            if (shouldLogResponse) {
-              const logResponse = async () => {
-                let responseBody = null
-                const contentType = response.headers.get('content-type') || ''
-                
-                if (responseCloneForLogging) {
-                  try {
-                    const clonedResponse = responseCloneForLogging
-                    if (contentType.includes('application/json') || contentType.includes('text/')) {
-                      const bodyText = await clonedResponse.text()
-                      if (contentType.includes('application/json')) {
-                        try {
-                          responseBody = JSON.parse(bodyText)
-                        } catch (_) {
-                          responseBody = bodyText
-                        }
-                      } else {
-                        responseBody = bodyText
-                      }
-                    }
-                  } catch (cloneError) {
-                    try {
-                      if (contentType.includes('application/json') || contentType.includes('text/')) {
-                        const bodyText = await response.text()
-                        if (contentType.includes('application/json')) {
-                          try {
-                            responseBody = JSON.parse(bodyText)
-                          } catch (_) {
-                            responseBody = bodyText
-                          }
-                        } else {
-                          responseBody = bodyText
-                        }
-                      }
-                    } catch (_) {
-                      responseBody = null
-                    }
-                  }
-                } else {
-                  responseBody = null
+            
+            let responseBodyString = null
+            let responseHeaders = {}
+            
+            try {
+              responseHeaders = headersToObject(response.headers)
+              const contentType = response.headers.get('content-type') || ''
+              const readBodyWithTimeout = async (resp, timeoutMs) => {
+                try {
+                  const timed = await Promise.race([
+                    resp.text(),
+                    new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
+                  ])
+                  return typeof timed === 'string' ? timed : null
+                } catch (_) {
+                  return null
                 }
-
+              }
+              
+              if (contentType.includes('application/json') || contentType.includes('text/')) {
                 try {
-                  const responseMeta = {
-                    ...requestMeta,
-                    statusCode: response.status,
-                    responseTimeMs: duration,
-                    responseHeaders: Object.fromEntries(response.headers.entries()),
-                    responseBody: responseBody
-                  }
-                  
-                  markSource(responseMeta, 'http-client')
-                  const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
-                  
-                  const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
-                  
-                  const metaCopy = { ...responseMeta }
-                  if (metaCopy.responseBody != null && typeof metaCopy.responseBody !== 'string') {
-                    try {
-                      metaCopy.responseBody = JSON.stringify(metaCopy.responseBody)
-                    } catch (_) {
-                      metaCopy.responseBody = String(metaCopy.responseBody)
+                  const clonedResponse = response.clone()
+                  const bodyText = await readBodyWithTimeout(clonedResponse, 200)
+                  if (bodyText) {
+                    if (contentType.includes('application/json')) {
+                      try {
+                        responseBodyString = JSON.stringify(JSON.parse(bodyText))
+                      } catch (_) {
+                        responseBodyString = bodyText
+                      }
+                    } else {
+                      responseBodyString = bodyText
                     }
-                  }
-                  
-                  const payload = {
-                    level,
-                    message,
-                    meta: {
-                      ...metaCopy,
-                      service: {
-                        name: serviceName,
-                        version: '1.0.0'
-                      },
-                      environment,
-                      timestamp: new Date().toISOString(),
-                      hostname: os.hostname()
+                    if (typeof responseBodyString === 'string' && responseBodyString.length > 5000) {
+                      responseBodyString = responseBodyString.slice(0, 5000)
                     }
                   }
+                } catch (_) {
                   try {
-                    transport.enqueue(payload, {
-                      'content-type': 'application/json'
-                    })
-                  } catch (enqueueErr) {
-                    sendOutboundLog(level, message, responseMeta)
-                  }
-                } catch (err) {
-                  try {
-                    const responseMeta = {
-                      ...requestMeta,
-                      statusCode: response.status,
-                      responseTimeMs: duration,
-                      responseHeaders: Object.fromEntries(response.headers.entries()),
-                      responseBody: responseBody != null ? String(responseBody) : null
-                    }
-                    
-                    markSource(responseMeta, 'http-client')
-                    const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
-                    
-                    const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
-                    
-                    const metaCopy = { ...responseMeta }
-                    if (metaCopy.responseBody != null && typeof metaCopy.responseBody !== 'string') {
-                      try {
-                        metaCopy.responseBody = JSON.stringify(metaCopy.responseBody)
-                      } catch (_) {
-                        metaCopy.responseBody = String(metaCopy.responseBody)
+                    const bodyText = await readBodyWithTimeout(response, 200)
+                    if (bodyText) {
+                      if (contentType.includes('application/json')) {
+                        try {
+                          responseBodyString = JSON.stringify(JSON.parse(bodyText))
+                        } catch (_) {
+                          responseBodyString = bodyText
+                        }
+                      } else {
+                        responseBodyString = bodyText
                       }
-                    }
-                    const payload = {
-                      level,
-                      message,
-                      meta: {
-                        ...metaCopy,
-                        service: {
-                          name: serviceName,
-                          version: '1.0.0'
-                        },
-                        environment,
-                        timestamp: new Date().toISOString(),
-                        hostname: os.hostname()
+                      if (typeof responseBodyString === 'string' && responseBodyString.length > 5000) {
+                        responseBodyString = responseBodyString.slice(0, 5000)
                       }
                     }
-                    try {
-                      transport.enqueue(payload, {
-                        'content-type': 'application/json'
-                      })
-                    } catch (enqueueErr) {
-                      sendOutboundLog(level, message, responseMeta)
-                    }
-                  } catch (innerErr) {
-                    console.error('[azify-logger] Erro ao logar resposta (fallback):', innerErr)
+                  } catch (_) {
                   }
                 }
               }
-              
-              logResponse().catch((err) => {
-                console.error('[azify-logger] Erro ao executar logResponse para', method, url, ':', err)
-                const responseMeta = {
-                  ...requestMeta,
-                  statusCode: response.status,
-                  responseTimeMs: duration,
-                  responseHeaders: Object.fromEntries(response.headers.entries()),
-                  responseBody: null
-                }
-                markSource(responseMeta, 'http-client')
-                const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
-                const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
-                try {
-                  sendOutboundLog(level, message, responseMeta)
-                } catch (fallbackErr) {
-                  console.error('[azify-logger] Erro ao enviar log de fallback:', fallbackErr)
-                }
-              })
+            } catch (_) {
             }
-
-            return response
-          } catch (error) {
-            const duration = Number((performance.now() - start).toFixed(2))
-            const errorMeta = {
+            
+            const responseMeta = {
               ...requestMeta,
-              responseTimeMs: duration
+              statusCode: response.status,
+              responseTimeMs: duration,
+              responseHeaders
             }
-            markSource(errorMeta, 'http-client')
-            const err = error instanceof Error ? error : new Error(String(error))
-            errorMeta.error = {
-              name: err.name,
-              message: err.message,
-              stack: err.stack
+            
+            if (responseBodyString !== null) {
+              responseMeta.responseBody = responseBodyString
             }
-            void sendOutboundLog('error', `[ERROR] ${method} ${url}`, errorMeta)
-            throw error
+            
+            markSource(responseMeta, 'http-client')
+            const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
+            const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
+            sendOutboundLog(level, message, responseMeta)
           }
+
+          return response
         }
       }
     }

package/sampling.js

@@ -45,6 +45,9 @@ const sourceSampleRates = {
 }
 
 const shouldSample = (level, source) => {
+  if (source === 'http-client') {
+    return true
+  }
   const key = typeof level === 'string' ? level.toLowerCase() : 'info'
   let rate = levelSampleRates[key] ?? levelSampleRates.default
   if (source && sourceSampleRates[source] !== undefined) {

package/scripts/redis-worker.js

@@ -226,15 +226,6 @@ function sanitizePayload(payload) {
     if (sanitized.meta.responseBody) {
       sanitized.meta.responseBody = sanitizeBody(sanitized.meta.responseBody)
     }
-    if (sanitized.meta.requestBody != null) {
-      if (typeof sanitized.meta.requestBody !== 'string') {
-        try {
-          sanitized.meta.requestBody = JSON.stringify(sanitized.meta.requestBody)
-        } catch (_) {
-          sanitized.meta.requestBody = String(sanitized.meta.requestBody)
-        }
-      }
-    }
   }
   
   return sanitized
@@ -257,18 +248,6 @@ async function deliver(entry) {
       sanitizedPayload = entry.payload
     }
   }
-  
-  if (sanitizedPayload && typeof sanitizedPayload === 'object' && sanitizedPayload.meta) {
-    if (sanitizedPayload.meta.requestBody != null) {
-      if (typeof sanitizedPayload.meta.requestBody !== 'string') {
-        try {
-          sanitizedPayload.meta.requestBody = JSON.stringify(sanitizedPayload.meta.requestBody)
-        } catch (_) {
-          sanitizedPayload.meta.requestBody = String(sanitizedPayload.meta.requestBody)
-        }
-      }
-    }
-  }
 
   await axios.post(target, sanitizedPayload, {
     headers: entry.headers || {},
@@ -346,16 +325,6 @@ async function processEntry(raw) {
     return
   }
 
-  if (entry && entry.payload && entry.payload.meta && entry.payload.meta.requestBody != null) {
-    if (typeof entry.payload.meta.requestBody !== 'string') {
-      try {
-        entry.payload.meta.requestBody = JSON.stringify(entry.payload.meta.requestBody)
-      } catch (_) {
-        entry.payload.meta.requestBody = String(entry.payload.meta.requestBody)
-      }
-    }
-  }
-
   const attempts = Number(entry.attempts || 0)
   try {
     await deliver(entry)

package/server.js

@@ -154,7 +154,6 @@ async function ensureIndexTemplate() {
               userAgent: { type: 'text' },
               environment: { type: 'keyword' },
               hostname: { type: 'keyword' },
-              requestBody: { type: 'text' },
               responseBody: { type: 'text' },
               error: {
                 properties: {
@@ -1701,7 +1700,8 @@ async function handleLog(req, res) {
             }
           } else if (Buffer.isBuffer(bodyValue)) {
             try {
-              return bodyValue.toString('utf8')
+              let str = bodyValue.toString('utf8')
+              return str
             } catch (_) {
               return '[Unable to serialize Buffer]'
             }