azify-logger 1.0.35 → 1.0.37

package/middleware-express.js

@@ -144,14 +144,29 @@ function createExpressLoggingMiddleware(options = {}) {
     return worker
   }
   
-  function sendLog(level, message, meta = {}) {
-    if (!transport || typeof transport.enqueue !== 'function') return
+  async function sendLog(level, message, meta = {}) {
+    if (!transport || typeof transport.enqueue !== 'function') {
+      try {
+        console.log(`[AZIFY-LOGGER-FALLBACK] ${message}`, JSON.stringify(meta, null, 2))
+      } catch (_) {
+      }
+      return
+    }
     
-    transport.enqueue({
-      level,
-      message,
-      meta
-    }, { 'content-type': 'application/json' })
+    try {
+      // AGUARDAR o enqueue para garantir que o log seja adicionado ao Redis antes de continuar
+      // transport.enqueue agora é assíncrono e sempre retorna uma Promise
+      await transport.enqueue({
+        level,
+        message,
+        meta
+      }, { 'content-type': 'application/json' })
+    } catch (err) {
+      try {
+        console.log(`[AZIFY-LOGGER-FALLBACK] ${message}`, JSON.stringify(meta, null, 2))
+      } catch (_) {
+      }
+    }
   }
 
   return function azifyExpressLoggingMiddleware(req, res, next) {
@@ -210,14 +225,14 @@ function createExpressLoggingMiddleware(options = {}) {
     
     const ctx = ensureRequestContext()
     
-    const logWithContext = (level, message, meta) => {
+    const logWithContext = async (level, message, meta) => {
       const otelCtx = getOtelTraceContext()
       const ctx = getRequestContext() || ensureRequestContext()
       
       meta.traceId = otelCtx?.traceId || meta.traceId || ctx.traceId
       meta.spanId = otelCtx?.spanId || meta.spanId || ctx.spanId
       meta.parentSpanId = otelCtx?.parentSpanId || meta.parentSpanId || ctx.parentSpanId
-      sendLog(level, message, meta)
+      await sendLog(level, message, meta)
     }
     
     function ensureIds() {
@@ -255,19 +270,20 @@ function createExpressLoggingMiddleware(options = {}) {
       }
     }
     
-    function emitResponseLog(meta, chunk) {
+    async function emitResponseLog(meta, chunk) {
       if (!config.captureResponseBody || chunk == null) {
-        logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+        await logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
         return
       }
 
       if (!meta.response) meta.response = {}
       meta.response.body = safeSerializeBody(chunk)
-      logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+      await logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
     }
 
     if (config.logRequest) {
-      process.nextTick(() => {
+      let requestLogEmitted = false
+      try {
         ensureIds()
         ensureHeaders()
         
@@ -300,25 +316,55 @@ function createExpressLoggingMiddleware(options = {}) {
         if (config.environment) meta.environment = config.environment
         
         logWithContext('info', `[REQUEST] ${method} ${url}`, meta)
-      })
-    }
-  
-    const originalEnd = res.end.bind(res)
-    
-    res.end = (chunk, encoding) => {
-      if (logSent) {
-        return originalEnd(chunk, encoding)
+        requestLogEmitted = true
+      } catch (err) {
+        try {
+          ensureIds()
+          const minimalMeta = {
+            traceId: reqCtx?.traceId || traceId,
+            spanId: reqCtx?.spanId || spanId,
+            parentSpanId: reqCtx?.parentSpanId || parentSpanId || null,
+            requestId: requestId || fastUUID(),
+            method,
+            url,
+            path,
+            timestamp: Date.now(),
+            hostname
+          }
+          if (serviceObj) minimalMeta.service = serviceObj
+          if (config.environment) minimalMeta.environment = config.environment
+          logWithContext('info', `[REQUEST] ${method} ${url}`, minimalMeta)
+          requestLogEmitted = true
+        } catch (_) {
+          try {
+            sendLog('info', `[REQUEST] ${method} ${url}`, {
+              method,
+              url,
+              path
+            })
+            requestLogEmitted = true
+          } catch (_) {
+            try {
+              console.log(`[AZIFY-LOGGER-EMERGENCY] [REQUEST] ${method} ${url}`)
+            } catch (_) {
+            }
+          }
+        }
       }
-      logSent = true
       
-      const result = originalEnd(chunk, encoding)
-
-      if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
-        responseChunk = chunk
-        responseChunkCaptured = true
+      if (!requestLogEmitted) {
+        try {
+          console.log(`[AZIFY-LOGGER-EMERGENCY] [REQUEST] ${method} ${url}`)
+        } catch (_) {
+        }
       }
+    }
+  
+    async function emitResponse() {
+      if (logSent) return
+      logSent = true
       
-      process.nextTick(() => {
+      try {
         ensureIds()
         
         const statusCode = res.statusCode || 200
@@ -353,12 +399,76 @@ function createExpressLoggingMiddleware(options = {}) {
         if (config.environment) meta.environment = config.environment
         
         const chunkToProcess = (responseChunk !== null && responseChunkCaptured) ? responseChunk : null
-        emitResponseLog(meta, chunkToProcess)
-      })
+        await 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
+          await emitResponseLog(meta, null)
+        } catch (fallbackErr) {
+          try {
+            ensureIds()
+            const statusCode = res.statusCode || 200
+            const duration = Date.now() - startTime
+            await sendLog('info', `[RESPONSE] ${method} ${url}`, {
+              traceId: reqCtx?.traceId || traceId,
+              spanId: reqCtx?.spanId || spanId,
+              parentSpanId: reqCtx?.parentSpanId || parentSpanId || null,
+              requestId: requestId || fastUUID(),
+              method,
+              url,
+              path,
+              statusCode,
+              durationMs: duration,
+              timestamp: Date.now(),
+              hostname
+            })
+          } catch (_) {
+          }
+        }
+      }
+    }
+
+    const originalEnd = res.end.bind(res)
+    
+    res.end = (chunk, encoding) => {
+      if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
+        responseChunk = chunk
+        responseChunkCaptured = true
+      }
       
+      const result = originalEnd(chunk, encoding)
+      void emitResponse()
       return result
     }
 
+    // Também capturar o evento 'finish' para garantir que o RESPONSE seja logado
+    // mesmo quando res.json() ou res.send() são usados sem chamar res.end() explicitamente
+    res.once('finish', () => {
+      void emitResponse()
+    })
+
     runWithRequestContext(ctx, () => {
       next()
     })

package/package.json

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

package/queue/redisQueue.js

@@ -29,6 +29,7 @@ function createRedisProducer(config = {}) {
   const streamKey = config.streamKey || DEFAULT_STREAM_KEY
   const maxLen = Number.isFinite(config.maxLen) ? config.maxLen : DEFAULT_MAXLEN
   const redisOptions = { ...defaultRedisOptions, ...(config.redisOptions || {}) }
+  const spool = config.spool || null
 
   const client = new Redis(url, redisOptions)
   let lastConnectionErrorLog = 0
@@ -69,8 +70,9 @@ function createRedisProducer(config = {}) {
   const BATCH_SIZE = 1
   const BATCH_TIMEOUT = 0
   let flushing = false
+  let currentSpool = spool
 
-  function flushBatch() {
+  async function flushBatch() {
     if (flushing || batch.length === 0) return
     flushing = true
 
@@ -80,12 +82,19 @@ function createRedisProducer(config = {}) {
       return
     }
 
-    setImmediate(() => {
+    try {
       if (entriesToFlush.length === 1) {
         const entry = entriesToFlush[0]
         if (entry) {
-          const payload = JSON.stringify(entry)
-          client.xadd(streamKey, 'MAXLEN', '~', maxLen, '*', 'entry', payload).catch(() => {})
+          try {
+            const payload = JSON.stringify(entry)
+            // AGUARDAR o xadd para garantir que o log seja adicionado ao Redis antes de continuar
+            await client.xadd(streamKey, 'MAXLEN', '~', maxLen, '*', 'entry', payload)
+          } catch (err) {
+            if (currentSpool) {
+              currentSpool.append(entry).catch(() => {})
+            }
+          }
         }
       } else {
         const pipeline = client.pipeline()
@@ -94,40 +103,58 @@ function createRedisProducer(config = {}) {
         for (let i = 0; i < entriesToFlush.length; i++) {
           const entry = entriesToFlush[i]
           if (!entry) continue
-          const payload = JSON.stringify(entry)
-          pipeline.xadd(streamKey, 'MAXLEN', '~', maxLen, '*', 'entry', payload)
-          validCount++
+          try {
+            const payload = JSON.stringify(entry)
+            pipeline.xadd(streamKey, 'MAXLEN', '~', maxLen, '*', 'entry', payload)
+            validCount++
+          } catch (err) {
+            if (currentSpool) {
+              currentSpool.append(entry).catch(() => {})
+            }
+          }
         }
         
         if (validCount > 0) {
-          pipeline.exec().catch(() => {})
+          await pipeline.exec().catch((err) => {
+            for (const entry of entriesToFlush) {
+              if (currentSpool) {
+                currentSpool.append(entry).catch(() => {})
+              }
+            }
+          })
         }
       }
-      
-      flushing = false
-      if (batch.length >= BATCH_SIZE) {
-        flushBatch()
-      } else if (batch.length > 0) {
-        scheduleFlush()
+    } catch (err) {
+      for (const entry of entriesToFlush) {
+        if (currentSpool) {
+          currentSpool.append(entry).catch(() => {})
+        }
       }
-    })
+    }
+    
+    flushing = false
+    if (batch.length >= BATCH_SIZE) {
+      setImmediate(() => { void flushBatch() })
+    } else if (batch.length > 0) {
+      scheduleFlush()
+    }
   }
 
   function scheduleFlush() {
     if (batchTimer || flushing) return
     
     if (batch.length >= BATCH_SIZE) {
-      flushBatch()
+      void flushBatch()
     } else if (BATCH_TIMEOUT === 0) {
       setImmediate(() => {
         if (!flushing) {
-          flushBatch()
+          void flushBatch()
         }
       })
     } else {
       batchTimer = setTimeout(() => {
         batchTimer = null
-        flushBatch()
+        void flushBatch()
       }, BATCH_TIMEOUT)
       
       if (typeof batchTimer.unref === 'function') {
@@ -136,7 +163,7 @@ function createRedisProducer(config = {}) {
     }
   }
 
-  function enqueue(entry) {
+  async function enqueue(entry) {
     batch.push(entry)
     
     if (batch.length >= BATCH_SIZE) {
@@ -144,7 +171,8 @@ function createRedisProducer(config = {}) {
         clearTimeout(batchTimer)
         batchTimer = null
       }
-      flushBatch()
+      // AGUARDAR o flushBatch quando o batch está cheio para garantir que o log seja adicionado ao Redis
+      await flushBatch()
     } else if (batch.length === 1) {
       scheduleFlush()
     }
@@ -156,7 +184,7 @@ function createRedisProducer(config = {}) {
       batchTimer = null
     }
     while (batch.length > 0) {
-      flushBatch()
+      await flushBatch()
       await new Promise(resolve => setTimeout(resolve, 10))
     }
     await client.quit().catch(() => {})
@@ -167,7 +195,11 @@ function createRedisProducer(config = {}) {
     client,
     streamKey,
     close,
-    flush: flushBatch
+    flush: flushBatch,
+    setSpool(newSpool) {
+      currentSpool = newSpool
+    },
+    _spool: null
   }
 }