azify-logger 1.0.32 → 1.0.34

package/middleware-express.js

@@ -297,6 +297,15 @@ function createExpressLoggingMiddleware(options = {}) {
           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
         

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",

package/register.js

@@ -84,11 +84,32 @@ try {
       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)
+        }
+      }
+    }
+    
+    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,
+        ...metaCopy,
         service: {
           name: serviceName,
           version: (meta && meta.service && meta.service.version) || '1.0.0'
@@ -739,6 +760,7 @@ try {
   } catch (_) {}
 
   try {
+
     if (typeof globalThis.fetch === 'function') {
       const g = globalThis
       if (!g.__azifyLoggerFetchPatched) {
@@ -760,6 +782,32 @@ try {
             return originalFetch(input, init)
           }
           
+          let url = 'unknown'
+          let method = 'GET'
+          
+          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 {
+              url = String(input)
+              method = (init?.method || 'GET').toUpperCase()
+            } catch (_) {
+              return originalFetch(input, init)
+            }
+          }
+          
+          const testMeta = { url }
+          if (isLoggerApiCall(testMeta)) {
+            return originalFetch(input, init)
+          }
+          
           let requestBody = null
           if (init && init.body != null) {
             try {
@@ -772,36 +820,30 @@ try {
                 requestBody = '[FormData]'
               } else if (body instanceof URLSearchParams) {
                 requestBody = body.toString()
-              } else if (typeof body === 'object') {
+              } 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
             }
           }
 
-          const request = ensureRequest(input, init)
-          const method = request.method.toUpperCase()
-          const url = request.url
-
-          const testMeta = { url }
-          if (isLoggerApiCall(testMeta)) {
-            return originalFetch(request)
-          }
-
           const ctx = getRequestContext()
           const traceId = (ctx?.traceId) || randomUUID()
           const parentSpanId = (ctx?.spanId) || null
           const requestId = (ctx?.requestId) || randomUUID()
           const spanId = randomBytes(8).toString('hex')
 
-          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)
-
           const requestMeta = {
             traceId,
             spanId,
@@ -809,16 +851,98 @@ try {
             requestId,
             method,
             url,
-            headers: Object.fromEntries(request.headers.entries())
+            headers: {}
           }
 
           if (requestBody != null) {
-            requestMeta.requestBody = requestBody
+            let finalRequestBody = requestBody
+            if (typeof requestBody !== 'string') {
+              try {
+                finalRequestBody = JSON.stringify(requestBody)
+              } catch (_) {
+                finalRequestBody = String(requestBody)
+              }
+            }
+            requestMeta.requestBody = finalRequestBody
+          }
+
+          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)
           }
 
           markSource(requestMeta, 'http-client')
-          if (HTTP_CLIENT_MODE === 'all') {
-            sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+          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
+            }
           }
 
           const childCtx = {
@@ -837,34 +961,32 @@ try {
 
             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) ||
-              hasTraceHeaders
+              (HTTP_CLIENT_MODE === 'errors' && (response.status >= 400 || wasRequestLogged)) ||
+              hasTraceHeaders ||
+              requestWasLogged
+
+            let responseCloneForLogging = null
+            if (shouldLogResponse) {
+              try {
+                responseCloneForLogging = response.clone()
+              } catch (cloneError) {
+                responseCloneForLogging = null
+              }
+            }
 
             if (shouldLogResponse) {
               const logResponse = async () => {
                 let responseBody = null
                 const contentType = response.headers.get('content-type') || ''
                 
-                try {
-                  const clonedResponse = response.clone()
-                  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) {
+                if (responseCloneForLogging) {
                   try {
+                    const clonedResponse = responseCloneForLogging
                     if (contentType.includes('application/json') || contentType.includes('text/')) {
-                      const bodyText = await response.text()
+                      const bodyText = await clonedResponse.text()
                       if (contentType.includes('application/json')) {
                         try {
                           responseBody = JSON.parse(bodyText)
@@ -875,9 +997,26 @@ try {
                         responseBody = bodyText
                       }
                     }
-                  } catch (_) {
-                    responseBody = null
+                  } 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
                 }
 
                 try {
@@ -893,7 +1032,37 @@ try {
                   const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
                   
                   const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
-                  sendOutboundLog(level, message, responseMeta)
+                  
+                  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 payload = {
+                    level,
+                    message,
+                    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'
+                    })
+                  } catch (enqueueErr) {
+                    sendOutboundLog(level, message, responseMeta)
+                  }
                 } catch (err) {
                   try {
                     const responseMeta = {
@@ -901,20 +1070,67 @@ try {
                       statusCode: response.status,
                       responseTimeMs: duration,
                       responseHeaders: Object.fromEntries(response.headers.entries()),
-                      responseBody: null
+                      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'
-                    sendOutboundLog(level, message, responseMeta)
-                  } catch (_) {
+                    
+                    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 payload = {
+                      level,
+                      message,
+                      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'
+                      })
+                    } catch (enqueueErr) {
+                      sendOutboundLog(level, message, responseMeta)
+                    }
+                  } catch (innerErr) {
+                    console.error('[azify-logger] Erro ao logar resposta (fallback):', innerErr)
                   }
                 }
               }
               
-              logResponse().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)
+                }
+              })
             }
 
             return response

package/scripts/redis-worker.js

@@ -226,6 +226,15 @@ 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
@@ -248,6 +257,18 @@ 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 || {},
@@ -325,6 +346,16 @@ 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,6 +154,7 @@ async function ensureIndexTemplate() {
               userAgent: { type: 'text' },
               environment: { type: 'keyword' },
               hostname: { type: 'keyword' },
+              requestBody: { type: 'text' },
               responseBody: { type: 'text' },
               error: {
                 properties: {
@@ -1691,28 +1692,16 @@ async function handleLog(req, res) {
           }
           
           if (typeof bodyValue === 'string') {
-            if (bodyValue.trim().startsWith('{') || bodyValue.trim().startsWith('[')) {
-              try {
-                let parsed = JSON.parse(bodyValue)
-                if (typeof parsed === 'object') {
-                  return parsed
-                }
-              } catch (_) { }
-            }
             return bodyValue
           } else if (typeof bodyValue === 'object' && bodyValue !== null) {
-            return bodyValue
+            try {
+              return JSON.stringify(bodyValue)
+            } catch (_) {
+              return String(bodyValue)
+            }
           } else if (Buffer.isBuffer(bodyValue)) {
             try {
-              let str = bodyValue.toString('utf8')
-              if (str.trim().startsWith('{') || str.trim().startsWith('[')) {
-                try {
-                  return JSON.parse(str)
-                } catch (_) {
-                  return str
-                }
-              }
-              return str
+              return bodyValue.toString('utf8')
             } catch (_) {
               return '[Unable to serialize Buffer]'
             }