azify-logger 1.0.37 → 1.0.38

package/middleware-express.js

@@ -144,29 +144,14 @@ function createExpressLoggingMiddleware(options = {}) {
     return worker
   }
   
-  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
-    }
+  function sendLog(level, message, meta = {}) {
+    if (!transport || typeof transport.enqueue !== 'function') return
     
-    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 (_) {
-      }
-    }
+    transport.enqueue({
+      level,
+      message,
+      meta
+    }, { 'content-type': 'application/json' })
   }
 
   return function azifyExpressLoggingMiddleware(req, res, next) {
@@ -225,14 +210,14 @@ function createExpressLoggingMiddleware(options = {}) {
     
     const ctx = ensureRequestContext()
     
-    const logWithContext = async (level, message, meta) => {
+    const logWithContext = (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
-      await sendLog(level, message, meta)
+      sendLog(level, message, meta)
     }
     
     function ensureIds() {
@@ -270,20 +255,19 @@ function createExpressLoggingMiddleware(options = {}) {
       }
     }
     
-    async function emitResponseLog(meta, chunk) {
+    function emitResponseLog(meta, chunk) {
       if (!config.captureResponseBody || chunk == null) {
-        await logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+        logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
         return
       }
 
       if (!meta.response) meta.response = {}
       meta.response.body = safeSerializeBody(chunk)
-      await logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+      logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
     }
 
     if (config.logRequest) {
-      let requestLogEmitted = false
-      try {
+      process.nextTick(() => {
         ensureIds()
         ensureHeaders()
         
@@ -316,159 +300,94 @@ function createExpressLoggingMiddleware(options = {}) {
         if (config.environment) meta.environment = config.environment
         
         logWithContext('info', `[REQUEST] ${method} ${url}`, meta)
-        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 (_) {
-            }
-          }
-        }
-      }
-      
-      if (!requestLogEmitted) {
-        try {
-          console.log(`[AZIFY-LOGGER-EMERGENCY] [REQUEST] ${method} ${url}`)
-        } catch (_) {
-        }
-      }
+      })
     }
   
-    async function emitResponse() {
-      if (logSent) return
-      logSent = true
+    const originalEnd = res.end.bind(res)
+    
+    res.end = (chunk, encoding) => {
+      const result = originalEnd(chunk, encoding)
+
+      if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
+        responseChunk = chunk
+        responseChunkCaptured = true
+      }
       
-      try {
-        ensureIds()
-        
-        const statusCode = res.statusCode || 200
-        const duration = Date.now() - startTime
-        const response = { statusCode, durationMs: duration }
+      if (!logSent) {
+        logSent = true
         
-        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
-        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) {
+        process.nextTick(() => {
           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(),
+            const response = { statusCode, durationMs: duration }
+            
+            if (config.captureHeaders) {
+              ensureHeaders()
+            }
+            
+            const requestObj = {
+              id: requestId,
               method,
               url,
               path,
-              statusCode,
-              durationMs: duration,
+              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
-            })
-          } catch (_) {
+            }
+            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 (_) {
+            }
           }
-        }
-      }
-    }
-
-    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.37",
+  "version": "1.0.38",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -53,6 +53,7 @@
     "adm-zip": "^0.5.16",
     "archiver": "^6.0.1",
     "axios": "^1.6.0",
+    "bull": "^4.16.5",
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "express-session": "^1.17.3",

package/queue/redisQueue.js

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