azify-logger 1.0.33 → 1.0.35

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,6 +292,7 @@ function createExpressLoggingMiddleware(options = {}) {
           parentSpanId: reqCtx.parentSpanId || null,
           requestId,
           request,
+          requestBody,
           timestamp: Date.now(),
           hostname
         }
@@ -359,6 +358,10 @@ function createExpressLoggingMiddleware(options = {}) {
       
       return result
     }
+
+    runWithRequestContext(ctx, () => {
+      next()
+    })
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "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,127 +883,20 @@ try {
             headers: {}
           }
 
-          if (requestBody != null) {
-            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
+            requestMeta.headers = Object.fromEntries(request.headers.entries())
+          } catch (_) {
+          }
 
-            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)
+          if (requestBodyString !== null) {
+            requestMeta.requestBody = requestBodyString
           }
 
           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 {
+          if (HTTP_CLIENT_MODE !== 'off') {
+            try {
               sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+            } catch (_) {
             }
           }
 
@@ -987,110 +909,156 @@ 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 shouldLogResponse =
-              HTTP_CLIENT_MODE === 'all' ||
-              (HTTP_CLIENT_MODE === 'errors' && response.status >= 400) ||
-              hasTraceHeaders
+            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
+          }
 
-            if (shouldLogResponse) {
-              const logResponse = async () => {
-                let responseBody = null
-                const contentType = response.headers.get('content-type') || ''
-                
+          const duration = Number((performance.now() - start).toFixed(2))
+          const shouldLogResponse = HTTP_CLIENT_MODE !== 'off'
+
+          if (shouldLogResponse) {
+            const headersToObject = (headers) => {
+              try {
+                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 {}
+            }
+            
+            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 clonedResponse = response.clone()
-                  if (contentType.includes('application/json') || contentType.includes('text/')) {
-                    const bodyText = await clonedResponse.text()
+                  const bodyText = await readBodyWithTimeout(clonedResponse, 200)
+                  if (bodyText) {
                     if (contentType.includes('application/json')) {
                       try {
-                        responseBody = JSON.parse(bodyText)
+                        responseBodyString = JSON.stringify(JSON.parse(bodyText))
                       } catch (_) {
-                        responseBody = bodyText
+                        responseBodyString = bodyText
                       }
                     } else {
-                      responseBody = bodyText
+                      responseBodyString = bodyText
+                    }
+                    if (typeof responseBodyString === 'string' && responseBodyString.length > 5000) {
+                      responseBodyString = responseBodyString.slice(0, 5000)
                     }
                   }
-                } catch (cloneError) {
+                } catch (_) {
                   try {
-                    if (contentType.includes('application/json') || contentType.includes('text/')) {
-                      const bodyText = await response.text()
+                    const bodyText = await readBodyWithTimeout(response, 200)
+                    if (bodyText) {
                       if (contentType.includes('application/json')) {
                         try {
-                          responseBody = JSON.parse(bodyText)
+                          responseBodyString = JSON.stringify(JSON.parse(bodyText))
                         } catch (_) {
-                          responseBody = bodyText
+                          responseBodyString = bodyText
                         }
                       } else {
-                        responseBody = bodyText
+                        responseBodyString = bodyText
+                      }
+                      if (typeof responseBodyString === 'string' && responseBodyString.length > 5000) {
+                        responseBodyString = responseBodyString.slice(0, 5000)
                       }
                     }
-                  } catch (_) {
-                    responseBody = null
-                  }
-                }
-
-                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'
-                  sendOutboundLog(level, message, responseMeta)
-                } catch (err) {
-                  try {
-                    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'
-                    sendOutboundLog(level, message, responseMeta)
                   } catch (_) {
                   }
                 }
               }
-              
-              logResponse().catch(() => {})
+            } 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
+            }
+            
+            try {
+              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 (err) {
+              try {
+                const fallbackMeta = {
+                  traceId: requestMeta.traceId || randomUUID(),
+                  spanId: requestMeta.spanId || randomBytes(8).toString('hex'),
+                  parentSpanId: requestMeta.parentSpanId || null,
+                  requestId: requestMeta.requestId || randomUUID(),
+                  method,
+                  url,
+                  statusCode: response.status,
+                  responseTimeMs: duration,
+                  headers: requestMeta.headers || {},
+                  responseHeaders: {}
+                }
+                markSource(fallbackMeta, '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, fallbackMeta)
+              } catch (_) {
+              }
             }
-            void sendOutboundLog('error', `[ERROR] ${method} ${url}`, errorMeta)
-            throw error
           }
+
+          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]'
             }