azify-logger 1.0.37 → 1.0.39

package/README.md

@@ -72,6 +72,8 @@ await fastify.listen({ port: 3000 })
 |----------|------------------------------------|-----------|
 | `APP_NAME` | -                                  | Nome da aplicação |
 | `AZIFY_LOGGER_URL` | `http://localhost:3001/log`        | URL do logger |
+| `AZIFY_LOGGER_REDIS_URL` | `redis://localhost:6381`           | URL do Redis (fila de logs) |
+| `AZIFY_LOGGER_REDIS_PASSWORD` | —                                  | **Obrigatório só em produção.** Em `NODE_ENV=production` o Redis exige senha; em dev/staging é opcional. |
 | `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://localhost:4318/v1/traces`  | Endpoint OTLP para traces (opcional) |
 | `NODE_ENV` | `development`                      | Ambiente |
 

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/middleware-fastify.js

@@ -1,5 +1,4 @@
 const { startRequestContext, runWithRequestContext, getRequestContext } = require('./store')
-const { createHttpLoggerTransport } = require('./streams/httpQueue')
 const os = require('os')
 
 let trace, otelContext
@@ -86,18 +85,20 @@ function createFastifyLoggingPlugin(options = {}) {
     captureHeaders: options.captureHeaders !== undefined ? options.captureHeaders : process.env.AZIFY_LOGGER_CAPTURE_HEADERS === 'true'
   }
 
-  const transport = createHttpLoggerTransport(config.loggerUrl, {})
   const hostname = os.hostname()
   const serviceObj = config.serviceName ? { name: config.serviceName, version: '1.0.0' } : null
 
   function sendLog(level, message, meta = {}) {
-    if (!transport || typeof transport.enqueue !== 'function') return
-    
-    transport.enqueue({
-      level,
-      message,
-      meta
-    }, { 'content-type': 'application/json' })
+    if (!config.loggerUrl) return
+    try {
+      const payload = { level, message, meta }
+      fetch(config.loggerUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(3000)
+      }).catch(() => {})
+    } catch (_) {}
   }
 
   return async function azifyFastifyPlugin(fastify, opts) {
@@ -288,6 +289,7 @@ function createFastifyLoggingPlugin(options = {}) {
       const url = logger.url
       const path = logger.path
       
+      let reqCtx = null
       let requestId, traceId, spanId, parentSpanId, clientIp, query, cachedHeaders
       let idsCreated = false
       let headersCached = false
@@ -431,5 +433,8 @@ function createFastifyLoggingPlugin(options = {}) {
   }
 }
 
-module.exports = createFastifyLoggingPlugin
+const fp = require('fastify-plugin')
+module.exports = function (options) {
+  return fp(createFastifyLoggingPlugin(options))
+}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -53,8 +53,11 @@
     "adm-zip": "^0.5.16",
     "archiver": "^6.0.1",
     "axios": "^1.6.0",
+    "bull": "^4.16.5",
     "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
     "express": "^4.18.2",
+    "fastify-plugin": "^5.0.0",
     "express-session": "^1.17.3",
     "ioredis": "^5.8.2",
     "js-yaml": "^4.1.0",

package/queue/redisQueue.js

@@ -28,8 +28,17 @@ function createRedisProducer(config = {}) {
 
   const streamKey = config.streamKey || DEFAULT_STREAM_KEY
   const maxLen = Number.isFinite(config.maxLen) ? config.maxLen : DEFAULT_MAXLEN
+  const password = config.password ?? process.env.AZIFY_LOGGER_REDIS_PASSWORD
+  const pass = password != null && String(password).trim() !== '' ? String(password).trim() : null
+  const isProd = process.env.NODE_ENV === 'production'
+  if (!pass && isProd) {
+    throw new Error('Redis requires a password in production. Set AZIFY_LOGGER_REDIS_PASSWORD (or options.redis.password).')
+  }
+
   const redisOptions = { ...defaultRedisOptions, ...(config.redisOptions || {}) }
-  const spool = config.spool || null
+  if (pass) {
+    redisOptions.password = pass
+  }
 
   const client = new Redis(url, redisOptions)
   let lastConnectionErrorLog = 0
@@ -42,14 +51,30 @@ function createRedisProducer(config = {}) {
     global.__azifyLoggerRedisErrorLastLog = 0
   }
   
+  function isRedisAuthError(err) {
+    if (!err) return false
+    const code = err.code || ''
+    const msg = (err.message || '').toLowerCase()
+    return code === 'NOAUTH' || code === 'WRONGPASS' || msg.includes('noauth') || msg.includes('wrongpass') || msg.includes('invalid password') || msg.includes('authentication failed')
+  }
+
+  function isRedisUnavailable(err) {
+    if (!err) return false
+    const code = err.code || ''
+    const msg = (err.message || '').toLowerCase()
+    if (code === 'ECONNREFUSED' || msg.includes('econnrefused') || msg.includes('redis')) return true
+    return isRedisAuthError(err)
+  }
+
   client.on('error', (err) => {
+    if (isRedisAuthError(err)) return
     const now = Date.now()
     if (!global.__azifyLoggerRedisErrorLogged && now - global.__azifyLoggerRedisErrorLastLog > ERROR_LOG_INTERVAL) {
-      if (err && (err.code === 'ECONNREFUSED' || err.message?.includes('ECONNREFUSED') || err.message?.includes('Redis'))) {
+      if (isRedisUnavailable(err)) {
         global.__azifyLoggerRedisErrorLogged = true
         global.__azifyLoggerRedisErrorLastLog = now
         connectionErrorCount++
-        process.stderr.write('[azify-logger] ⚠️  Redis indisponível. O sistema de logging está desabilitado. A aplicação continua funcionando normalmente.\n')
+        process.stderr.write('[azify-logger] ⚠️  Redis unavailable. Logging is disabled. The application continues to run normally.\n')
         lastConnectionErrorLog = now
       }
     }
@@ -70,9 +95,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 +106,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 +120,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 +162,7 @@ function createRedisProducer(config = {}) {
     }
   }
 
-  async function enqueue(entry) {
+  function enqueue(entry) {
     batch.push(entry)
     
     if (batch.length >= BATCH_SIZE) {
@@ -171,8 +170,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 +182,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 +193,7 @@ function createRedisProducer(config = {}) {
     client,
     streamKey,
     close,
-    flush: flushBatch,
-    setSpool(newSpool) {
-      currentSpool = newSpool
-    },
-    _spool: null
+    flush: flushBatch
   }
 }