azify-logger 1.0.28 → 1.0.30

package/queue/redisQueue.js

@@ -34,35 +34,28 @@ function createRedisProducer(config = {}) {
   let lastConnectionErrorLog = 0
   let lastEnqueueErrorLog = 0
   let connectionErrorCount = 0
-  const ERROR_LOG_INTERVAL = 300000 // 5 minutos entre logs (evitar logs repetidos)
+  const ERROR_LOG_INTERVAL = 300000
   
-  // Flag global compartilhada entre todas as instâncias para garantir apenas 1 log por processo
   if (typeof global.__azifyLoggerRedisErrorLogged === 'undefined') {
     global.__azifyLoggerRedisErrorLogged = false
     global.__azifyLoggerRedisErrorLastLog = 0
   }
   
   client.on('error', (err) => {
-    // Log apenas uma vez por processo inteiro (compartilhado entre producer e worker)
     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'))) {
         global.__azifyLoggerRedisErrorLogged = true
         global.__azifyLoggerRedisErrorLastLog = now
         connectionErrorCount++
-        // Usar process.stderr.write para evitar interceptação do console
-        // Mensagem clara: aplicação continua funcionando, apenas logging está desabilitado
         process.stderr.write('[azify-logger] ⚠️  Redis indisponível. O sistema de logging está desabilitado. A aplicação continua funcionando normalmente.\n')
         lastConnectionErrorLog = now
       }
     }
-    // Após primeira mensagem, não logar mais - silenciar completamente
   })
   client.on('end', () => {
-    // Não logar - silenciar completamente
   })
   client.on('connect', () => {
-    // Resetar contador quando conectar com sucesso (sem logar)
     if (connectionErrorCount > 0 || global.__azifyLoggerRedisErrorLogged) {
       connectionErrorCount = 0
       lastConnectionErrorLog = 0
@@ -71,52 +64,52 @@ function createRedisProducer(config = {}) {
     }
   })
 
-  // BATCHING: acumular logs e enviar em batch para reduzir overhead
   const batch = []
   let batchTimer = null
-  const BATCH_SIZE = 100 // Batch size balanceado (200 era muito grande, causava latência)
-  const BATCH_TIMEOUT = 150 // Timeout balanceado
+  const BATCH_SIZE = 1
+  const BATCH_TIMEOUT = 0
   let flushing = false
 
   function flushBatch() {
     if (flushing || batch.length === 0) return
     flushing = true
 
-    // OTIMIZAÇÃO: enviar TODOS os logs disponíveis no batch (até BATCH_SIZE)
-    // Isso maximiza eficiência do pipeline Redis
     const entriesToFlush = batch.splice(0, BATCH_SIZE)
-    if (entriesToFlush.length === 0) {
+    if (!entriesToFlush.length) {
       flushing = false
       return
     }
 
     setImmediate(() => {
-      try {
-        // Usar pipeline do Redis para enviar múltiplos logs de uma vez
+      if (entriesToFlush.length === 1) {
+        const entry = entriesToFlush[0]
+        if (entry) {
+          const payload = JSON.stringify(entry)
+          client.xadd(streamKey, 'MAXLEN', '~', maxLen, '*', 'entry', payload).catch(() => {})
+        }
+      } else {
         const pipeline = client.pipeline()
+        let validCount = 0
         
-        for (const entry of entriesToFlush) {
-          try {
-            const payload = JSON.stringify(entry)
-            pipeline.xadd(streamKey, 'MAXLEN', '~', maxLen, '*', 'entry', payload)
-          } catch (err) {
-            // Erro ao serializar - ignorar silenciosamente
-          }
+        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++
         }
         
-        // Executar pipeline - muito mais eficiente que múltiplos xadd
-        pipeline.exec().catch(() => {
-          // Erro silencioso - não travar aplicação
-        })
-      } catch (err) {
-        // Erro silencioso - não travar aplicação
-      } finally {
-        flushing = false
-        // Se ainda há logs no batch, agendar próximo flush
-        if (batch.length > 0) {
-          scheduleFlush()
+        if (validCount > 0) {
+          pipeline.exec().catch(() => {})
         }
       }
+      
+      flushing = false
+      if (batch.length >= BATCH_SIZE) {
+        flushBatch()
+      } else if (batch.length > 0) {
+        scheduleFlush()
+      }
     })
   }
 
@@ -124,10 +117,14 @@ function createRedisProducer(config = {}) {
     if (batchTimer || flushing) return
     
     if (batch.length >= BATCH_SIZE) {
-      // Flush imediato se batch está cheio
       flushBatch()
+    } else if (BATCH_TIMEOUT === 0) {
+      setImmediate(() => {
+        if (!flushing) {
+          flushBatch()
+        }
+      })
     } else {
-      // Flush após timeout
       batchTimer = setTimeout(() => {
         batchTimer = null
         flushBatch()
@@ -140,25 +137,26 @@ function createRedisProducer(config = {}) {
   }
 
   function enqueue(entry) {
-    // OTIMIZAÇÃO: adicionar ao batch ao invés de enviar imediatamente
-    // Isso reduz drasticamente o número de operações Redis
-    try {
-      batch.push(entry)
+    batch.push(entry)
+    
+    if (batch.length >= BATCH_SIZE) {
+      if (batchTimer) {
+        clearTimeout(batchTimer)
+        batchTimer = null
+      }
+      flushBatch()
+    } else if (batch.length === 1) {
       scheduleFlush()
-    } catch (err) {
-      // Erro silencioso - não travar aplicação
     }
   }
 
   async function close() {
-    // Flush batch restante antes de fechar
     if (batchTimer) {
       clearTimeout(batchTimer)
       batchTimer = null
     }
     while (batch.length > 0) {
       flushBatch()
-      // Aguardar um pouco para flush completar
       await new Promise(resolve => setTimeout(resolve, 10))
     }
     await client.quit().catch(() => {})

package/register-otel.js

@@ -3,6 +3,8 @@ try {
   const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http')
   const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express')
   const { RestifyInstrumentation } = require('@opentelemetry/instrumentation-restify')
+  const { Resource } = require('@opentelemetry/resources')
+  const { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } = require('@opentelemetry/semantic-conventions')
 
   const serviceName = process.env.OTEL_SERVICE_NAME || process.env.APP_NAME || 'app'
   const serviceVersion = process.env.OTEL_SERVICE_VERSION || '1.0.0'
@@ -10,6 +12,12 @@ try {
   process.env.OTEL_SERVICE_NAME = serviceName
   process.env.OTEL_SERVICE_VERSION = serviceVersion
 
+  const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT
+  if (otlpEndpoint) {
+    process.env.OTEL_EXPORTER_OTLP_ENDPOINT = otlpEndpoint
+    process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT = otlpEndpoint
+  }
+
   let collectorHost = null
   let collectorPath = null
   try {
@@ -62,9 +70,109 @@ try {
     enabled: true
   })
 
+  let traceExporter = null
+  if (otlpEndpoint) {
+    try {
+      let endpointUrl
+      try {
+        endpointUrl = new URL(otlpEndpoint)
+      } catch (urlErr) {
+        throw new Error(`URL inválida: ${otlpEndpoint}`)
+      }
+      
+      const http = require('http')
+      const url = new URL(otlpEndpoint)
+      
+      traceExporter = {
+        export: function(spans, resultCallback) {
+          if (!spans || spans.length === 0) {
+            if (resultCallback) resultCallback({ code: 0 })
+            return
+          }
+          
+          try {
+            const resourceSpans = [{
+              resource: {
+                attributes: [
+                  { key: 'service.name', value: { stringValue: serviceName } },
+                  { key: 'service.version', value: { stringValue: serviceVersion } }
+                ]
+              },
+              scopeSpans: [{
+                spans: spans.map(span => {
+                  const ctx = span.spanContext()
+                  return {
+                    traceId: ctx.traceId.replace(/-/g, '').padStart(32, '0').substring(0, 32),
+                    spanId: ctx.spanId.replace(/-/g, '').padStart(16, '0').substring(0, 16),
+                    name: span.name || 'span',
+                    kind: span.kind || 1,
+                    startTimeUnixNano: String(span.startTime?.[0] * 1e9 + (span.startTime?.[1] || 0) || Date.now() * 1e6),
+                    endTimeUnixNano: String(span.endTime?.[0] * 1e9 + (span.endTime?.[1] || 0) || Date.now() * 1e6),
+                    attributes: Object.entries(span.attributes || {}).map(([k, v]) => ({
+                      key: k,
+                      value: { stringValue: String(v) }
+                    }))
+                  }
+                })
+              }]
+            }]
+            
+            const payload = JSON.stringify({ resourceSpans })
+            
+            const options = {
+              hostname: url.hostname,
+              port: url.port || (url.protocol === 'https:' ? 443 : 80),
+              path: url.pathname,
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload)
+              }
+            }
+            
+            const req = http.request(options, (res) => {
+              let data = ''
+              res.on('data', (chunk) => { data += chunk })
+              res.on('end', () => {
+                if (res.statusCode >= 200 && res.statusCode < 300) {
+                  if (resultCallback) resultCallback({ code: 0 })
+                } else {
+                  if (resultCallback) resultCallback({ code: 1, error: new Error(`HTTP ${res.statusCode}`) })
+                }
+              })
+            })
+            
+            req.on('error', (err) => {
+              if (resultCallback) resultCallback({ code: 1, error: err })
+            })
+            
+            req.write(payload)
+            req.end()
+          } catch (err) {
+            if (resultCallback) resultCallback({ code: 1, error: err })
+          }
+        },
+        shutdown: function() {
+          return Promise.resolve()
+        }
+      }
+      
+    } catch (err) {
+    }
+  }
+
+  let spanProcessor = null
+  if (traceExporter) {
+    const { SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base')
+    spanProcessor = new SimpleSpanProcessor(traceExporter)
+  }
+  
   const sdk = new NodeSDK({
-    serviceName,
-    serviceVersion,
+    resource: new Resource({
+      [SEMRESATTRS_SERVICE_NAME]: serviceName,
+      [SEMRESATTRS_SERVICE_VERSION]: serviceVersion
+    }),
+    spanProcessor,
     instrumentations: [
       httpInstrumentation,
       expressInstrumentation,

package/register.js

@@ -175,14 +175,17 @@ try {
             
             logger.info = function(obj, msg, ...args) {
               const ctx = getRequestContext()
-              if (ctx && ctx.traceId) {
+              const otelCtx = !ctx || !ctx.traceId ? getOtelTraceContext() : null
+              const traceCtx = ctx || otelCtx
+              
+              if (traceCtx && traceCtx.traceId) {
                 if (typeof obj === 'object' && obj !== null) {
-                  obj.traceId = ctx.traceId
-                  obj.spanId = ctx.spanId
-                  obj.parentSpanId = ctx.parentSpanId
-                  obj.requestId = ctx.requestId
+                  obj.traceId = traceCtx.traceId
+                  obj.spanId = traceCtx.spanId
+                  obj.parentSpanId = traceCtx.parentSpanId
+                  obj.requestId = traceCtx.requestId || ctx?.requestId
                 } else {
-                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                  obj = { traceId: traceCtx.traceId, spanId: traceCtx.spanId, parentSpanId: traceCtx.parentSpanId, requestId: traceCtx.requestId || ctx?.requestId, msg: obj }
                 }
               }
               return originalInfo.call(this, obj, msg, ...args)
@@ -190,14 +193,17 @@ try {
             
             logger.error = function(obj, msg, ...args) {
               const ctx = getRequestContext()
-              if (ctx && ctx.traceId) {
+              const otelCtx = !ctx || !ctx.traceId ? getOtelTraceContext() : null
+              const traceCtx = ctx || otelCtx
+              
+              if (traceCtx && traceCtx.traceId) {
                 if (typeof obj === 'object' && obj !== null) {
-                  obj.traceId = ctx.traceId
-                  obj.spanId = ctx.spanId
-                  obj.parentSpanId = ctx.parentSpanId
-                  obj.requestId = ctx.requestId
+                  obj.traceId = traceCtx.traceId
+                  obj.spanId = traceCtx.spanId
+                  obj.parentSpanId = traceCtx.parentSpanId
+                  obj.requestId = traceCtx.requestId || ctx?.requestId
                 } else {
-                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                  obj = { traceId: traceCtx.traceId, spanId: traceCtx.spanId, parentSpanId: traceCtx.parentSpanId, requestId: traceCtx.requestId || ctx?.requestId, msg: obj }
                 }
               }
               return originalError.call(this, obj, msg, ...args)
@@ -205,14 +211,17 @@ try {
             
             logger.warn = function(obj, msg, ...args) {
               const ctx = getRequestContext()
-              if (ctx && ctx.traceId) {
+              const otelCtx = !ctx || !ctx.traceId ? getOtelTraceContext() : null
+              const traceCtx = ctx || otelCtx
+              
+              if (traceCtx && traceCtx.traceId) {
                 if (typeof obj === 'object' && obj !== null) {
-                  obj.traceId = ctx.traceId
-                  obj.spanId = ctx.spanId
-                  obj.parentSpanId = ctx.parentSpanId
-                  obj.requestId = ctx.requestId
+                  obj.traceId = traceCtx.traceId
+                  obj.spanId = traceCtx.spanId
+                  obj.parentSpanId = traceCtx.parentSpanId
+                  obj.requestId = traceCtx.requestId || ctx?.requestId
                 } else {
-                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                  obj = { traceId: traceCtx.traceId, spanId: traceCtx.spanId, parentSpanId: traceCtx.parentSpanId, requestId: traceCtx.requestId || ctx?.requestId, msg: obj }
                 }
               }
               return originalWarn.call(this, obj, msg, ...args)
@@ -220,14 +229,17 @@ try {
             
             logger.debug = function(obj, msg, ...args) {
               const ctx = getRequestContext()
-              if (ctx && ctx.traceId) {
+              const otelCtx = !ctx || !ctx.traceId ? getOtelTraceContext() : null
+              const traceCtx = ctx || otelCtx
+              
+              if (traceCtx && traceCtx.traceId) {
                 if (typeof obj === 'object' && obj !== null) {
-                  obj.traceId = ctx.traceId
-                  obj.spanId = ctx.spanId
-                  obj.parentSpanId = ctx.parentSpanId
-                  obj.requestId = ctx.requestId
+                  obj.traceId = traceCtx.traceId
+                  obj.spanId = traceCtx.spanId
+                  obj.parentSpanId = traceCtx.parentSpanId
+                  obj.requestId = traceCtx.requestId || ctx?.requestId
                 } else {
-                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                  obj = { traceId: traceCtx.traceId, spanId: traceCtx.spanId, parentSpanId: traceCtx.parentSpanId, requestId: traceCtx.requestId || ctx?.requestId, msg: obj }
                 }
               }
               return originalDebug.call(this, obj, msg, ...args)
@@ -235,14 +247,17 @@ try {
             
             logger.fatal = function(obj, msg, ...args) {
               const ctx = getRequestContext()
-              if (ctx && ctx.traceId) {
+              const otelCtx = !ctx || !ctx.traceId ? getOtelTraceContext() : null
+              const traceCtx = ctx || otelCtx
+              
+              if (traceCtx && traceCtx.traceId) {
                 if (typeof obj === 'object' && obj !== null) {
-                  obj.traceId = ctx.traceId
-                  obj.spanId = ctx.spanId
-                  obj.parentSpanId = ctx.parentSpanId
-                  obj.requestId = ctx.requestId
+                  obj.traceId = traceCtx.traceId
+                  obj.spanId = traceCtx.spanId
+                  obj.parentSpanId = traceCtx.parentSpanId
+                  obj.requestId = traceCtx.requestId || ctx?.requestId
                 } else {
-                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                  obj = { traceId: traceCtx.traceId, spanId: traceCtx.spanId, parentSpanId: traceCtx.parentSpanId, requestId: traceCtx.requestId || ctx?.requestId, msg: obj }
                 }
               }
               return originalFatal.call(this, obj, msg, ...args)
@@ -250,14 +265,17 @@ try {
             
             logger.trace = function(obj, msg, ...args) {
               const ctx = getRequestContext()
-              if (ctx && ctx.traceId) {
+              const otelCtx = !ctx || !ctx.traceId ? getOtelTraceContext() : null
+              const traceCtx = ctx || otelCtx
+              
+              if (traceCtx && traceCtx.traceId) {
                 if (typeof obj === 'object' && obj !== null) {
-                  obj.traceId = ctx.traceId
-                  obj.spanId = ctx.spanId
-                  obj.parentSpanId = ctx.parentSpanId
-                  obj.requestId = ctx.requestId
+                  obj.traceId = traceCtx.traceId
+                  obj.spanId = traceCtx.spanId
+                  obj.parentSpanId = traceCtx.parentSpanId
+                  obj.requestId = traceCtx.requestId || ctx?.requestId
                 } else {
-                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                  obj = { traceId: traceCtx.traceId, spanId: traceCtx.spanId, parentSpanId: traceCtx.parentSpanId, requestId: traceCtx.requestId || ctx?.requestId, msg: obj }
                 }
               }
               return originalTrace.call(this, obj, msg, ...args)

package/sampling.js

@@ -36,7 +36,7 @@ const HTTP_CLIENT_MODE = (process.env.AZIFY_LOGGER_HTTP_CLIENT_LOGGING || 'all')
 
 const httpClientSampleRate = resolveSampleRate(
   'AZIFY_LOGGER_HTTP_SAMPLE_RATE',
-  HTTP_CLIENT_MODE === 'all' ? 1 : 1  // Sempre 1.0 (100%) quando HTTP_CLIENT_MODE === 'all'
+  HTTP_CLIENT_MODE === 'all' ? 1 : 1
 )
 
 const sourceSampleRates = {