azify-logger 1.0.32 → 1.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.32",
+  "version": "1.0.33",
   "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,131 @@ 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 = {}
+              }
+            }
+            
+            markSource(requestMeta, 'http-client')
+            const hasTraceHeaders = !!(requestMeta.traceId && requestMeta.spanId)
+            const shouldLogRequest =
+              HTTP_CLIENT_MODE === 'all' ||
+              hasTraceHeaders
+
+            if (shouldLogRequest) {
+              if (hasTraceHeaders) {
+                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()
+                  }
+                }
+                transport.enqueue(payload, {
+                  'content-type': 'application/json'
+                })
+              } else {
+                sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+              }
+            }
+            
+            return originalFetch(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' ||
+            hasTraceHeaders
+
+          if (shouldLogRequest) {
+            if (hasTraceHeaders) {
+              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()
+                }
+              }
+              transport.enqueue(payload, {
+                'content-type': 'application/json'
+              })
+            } else {
+              sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+            }
           }
 
           const childCtx = {

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]'
             }