azify-logger 1.0.28 → 1.0.29

package/streams/httpQueue.js

@@ -2,7 +2,13 @@ const axios = require('axios')
 const http = require('http')
 const https = require('https')
 const path = require('path')
-const { randomUUID } = require('crypto')
+
+function fastUUID() {
+  const timestamp = Date.now().toString(36)
+  const randomPart = Math.random().toString(36).substring(2, 15)
+  const randomPart2 = Math.random().toString(36).substring(2, 15)
+  return `${timestamp}-${randomPart}-${randomPart2}`.substring(0, 36)
+}
 
 const { createRedisProducer, DEFAULT_STREAM_KEY, DEFAULT_REDIS_URL } = require('../queue/redisQueue')
 const { createFileSpool } = require('../queue/fileQueue')
@@ -107,16 +113,32 @@ function createHttpLoggerTransport (loggerUrl, overrides) {
     try {
       return createRedisStreamTransport(loggerUrl, options, redisConfig)
     } catch (err) {
-      // Erro ao inicializar Redis - retornar noopTransport silenciosamente
-      // Não travar aplicação se Redis não estiver disponível
-      // Não logar - silenciar completamente para não poluir logs
-      return noopTransport
+      const errorMsg = `[azify-logger] ❌ ERRO: Redis é obrigatório mas falhou ao inicializar.\n` +
+        `  Mensagem: ${err.message}\n` +
+        `  Verifique se:\n` +
+        `  1. ioredis está instalado: npm install ioredis\n` +
+        `  2. Redis está configurado corretamente (AZIFY_LOGGER_REDIS_URL)\n` +
+        `  3. Redis está rodando e acessível\n`
+      throw new Error(errorMsg)
     }
   }
 
-  // Se Redis não estiver configurado, retornar noopTransport
-  // Não usar fallback síncrono para não travar aplicação
-  return noopTransport
+  const defaultRedisConfig = {
+    url: DEFAULT_REDIS_URL,
+    streamKey: DEFAULT_STREAM_KEY
+  }
+  
+  try {
+    return createRedisStreamTransport(loggerUrl, options, defaultRedisConfig)
+  } catch (err) {
+    const errorMsg = `[azify-logger] ❌ ERRO: Redis é obrigatório mas não está disponível.\n` +
+      `  Mensagem: ${err.message}\n` +
+      `  Verifique se:\n` +
+      `  1. ioredis está instalado: npm install ioredis\n` +
+      `  2. Redis está rodando em ${DEFAULT_REDIS_URL}\n` +
+      `  3. Configure AZIFY_LOGGER_REDIS_URL se Redis estiver em outro endereço\n`
+    throw new Error(errorMsg)
+  }
 }
 
 function createRedisStreamTransport (loggerUrl, options, redisConfig) {
@@ -124,111 +146,76 @@ function createRedisStreamTransport (loggerUrl, options, redisConfig) {
   try {
     producer = createRedisProducer(redisConfig)
   } catch (err) {
-    // Erro ao criar producer - retornar noopTransport silenciosamente
-    // Não logar - silenciar completamente para não poluir logs
-    return noopTransport
+    throw new Error(`Falha ao criar producer Redis: ${err.message}`)
   }
 
   if (!producer) {
-    return noopTransport
+    throw new Error('Falha ao criar producer Redis: producer é null')
   }
 
   let spool = null
-  try {
-    spool = createFileSpool({
-      directory: redisConfig.spoolDir || path.join(process.cwd(), '.azify-logger-spool'),
-      flushInterval: options.flushInterval,
-      batchSize: options.batchSize,
-      async pushFn (entries) {
-        if (producer) {
-          for (const entry of entries) {
-            try {
-              await producer.enqueue(entry).catch(() => {
-                // Erro ao enfileirar - ignorar silenciosamente
-              })
-            } catch (err) {
-              // Erro ao enfileirar - ignorar silenciosamente
+  if (createFileSpool) {
+    try {
+      spool = createFileSpool({
+        directory: redisConfig.spoolDir || path.join(process.cwd(), '.azify-logger-spool'),
+        flushInterval: options.flushInterval,
+        batchSize: options.batchSize,
+        async pushFn (entries) {
+          if (producer) {
+            for (const entry of entries) {
+              try {
+                await producer.enqueue(entry).catch(() => {
+                })
+              } catch (err) {
+              }
             }
           }
         }
-      }
-    })
-  } catch (err) {
-    // Erro ao criar spool - continuar sem spool silenciosamente
-    // Não logar - silenciar completamente para não poluir logs
+      })
+    } catch (err) {
+    }
   }
 
   if (spool) {
     spool.flush().catch(() => {})
   }
 
-  try {
-    ensureWorker(redisConfig, { autoRestart: true, stdio: 'inherit' })
-  } catch (err) {
-    // Erro ao garantir worker - continuar sem worker silenciosamente
-    // Não logar - silenciar completamente para não poluir logs
+  if (ensureWorker) {
+    try {
+      ensureWorker(redisConfig, { autoRestart: true, stdio: 'inherit' })
+    } catch (err) {
+      process.stderr.write(`[azify-logger] ⚠️  Aviso: Falha ao inicializar worker: ${err.message}\n`)
+    }
   }
 
   function pushEntry(entry) {
-    // OTIMIZAÇÃO: Remover setImmediate aqui - já estamos dentro de um setImmediate (do middleware)
-    // producer.enqueue() já faz seu próprio setImmediate
-    // Isso reduz de 3 para 2 níveis de setImmediate aninhados
-    try {
-      if (!producer) {
-        // Se producer não estiver disponível, tentar spool
-        if (spool) {
-          spool.append(entry).catch(() => {})
-        }
-        return
-      }
-      
-      // Não aguardar - fazer fire-and-forget para não bloquear
-      // producer.enqueue() já faz setImmediate internamente
-      producer.enqueue(entry).catch(() => {
-        // Erro ao enfileirar no Redis - tentar spool
-        if (spool) {
-          spool.append(entry).catch(() => {})
-        }
-      })
-    } catch (err) {
-      // Erro ao preparar entrada - ignorar silenciosamente
+    if (!producer) {
       if (spool) {
         spool.append(entry).catch(() => {})
       }
+      return
     }
+    
+    producer.enqueue(entry)
   }
 
   return {
     enqueue (payload, headers = {}) {
-      // OTIMIZAÇÃO: Criar entry inline para reduzir overhead
-      // randomUUID() e Date.now() são rápidos, mas podemos otimizar verificando producer primeiro
-      try {
-        // Criar entry apenas quando necessário (após verificações básicas)
-        const entry = {
-          id: randomUUID(),
-          loggerUrl,
-          headers,
-          payload,
-          createdAt: Date.now(),
-          attempts: 0
-        }
-        // pushEntry não tem setImmediate agora - chama direto producer.enqueue()
-        // producer.enqueue() faz setImmediate → client.xadd() (Redis I/O assíncrono)
-        pushEntry(entry)
-      } catch (err) {
-        // Erro ao criar entrada - ignorar silenciosamente
-        // Não travar aplicação por erro no logger
+      const entry = {
+        id: fastUUID(),
+        loggerUrl,
+        headers: headers || {},
+        payload
       }
+      pushEntry(entry)
     },
     async flush () {
       try {
         if (spool) {
           await spool.flush().catch(() => {
-            // Erro ao fazer flush - ignorar silenciosamente
           })
         }
       } catch (err) {
-        // Erro ao fazer flush - ignorar silenciosamente
       }
     }
   }
@@ -303,7 +290,6 @@ function buildInlineTransport (loggerUrl, options) {
         }
       }
     } catch (_) {
-      // remaining items already reinserted in queue
     } finally {
       flushing = false
       if (queue.length) {
@@ -354,4 +340,3 @@ function createHttpAgents (options) {
 module.exports = {
   createHttpLoggerTransport
 }
-