azify-logger 1.0.28 → 1.0.30

package/README.md

@@ -10,15 +10,15 @@ Sistema de logging centralizado com OpenTelemetry e OpenSearch para múltiplas a
 |----------|-----|
 | **Development** | `http://localhost:3001/log` |
 | **Staging** | `https://logsdashboard.azify.dev/send` |
-| **Production** | `https://logsdashboard.azify.prd/send` | (a configurar)
+| **Production** | `https://cadence.aztech.host/send` | 
 
 ### URLs para acessar os logs:
 
-| Ambiente | URL |
-|----------|-----|
-| **Development** | Grafana: `http://localhost:3002` |
+| Ambiente | URL                               |
+|----------|-----------------------------------|
+| **Development** | `http://localhost:3002`  |
 | **Staging** | `https://logsdashboard.azify.dev` |
-| **Production** | `https://logsdashboard.azify.com` |
+| **Production** | `https://cadence.aztech.host`     |
 
 ## 📦 Instalação
 
@@ -49,16 +49,31 @@ APP_NAME=nome-app
 require('azify-logger')
 const express = require('express')
 const app = express()
-// Logs automáticos via OpenTelemetry
+const azifyMiddleware = require('azify-logger/middleware-express')
+app.use(azifyMiddleware())
+```
+
+### Para aplicações Fastify:
+
+```javascript
+const fastify = require('fastify')()
+const azifyPlugin = require('azify-logger/middleware-fastify')
+
+await fastify.register(azifyPlugin, {
+  serviceName: 'minha-app'
+})
+
+await fastify.listen({ port: 3000 })
 ```
 
 ## ⚙️ Variáveis de Ambiente
 
-| Variável | Padrão | Descrição |
-|----------|-------|-----------|
-| `APP_NAME` | - | Nome da aplicação |
-| `AZIFY_LOGGER_URL` | `http://localhost:3001/log` | URL do logger |
-| `NODE_ENV` | `development` | Ambiente |
+| Variável | Padrão                             | Descrição |
+|----------|------------------------------------|-----------|
+| `APP_NAME` | -                                  | Nome da aplicação |
+| `AZIFY_LOGGER_URL` | `http://localhost:3001/log`        | URL do logger |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://localhost:4318/v1/traces`  | Endpoint OTLP para traces (opcional) |
+| `NODE_ENV` | `development`                      | Ambiente |
 
 ## 🎯 O Que Você Ganha
 
@@ -67,6 +82,27 @@ const app = express()
 - ✅ **Trace Consistente**: REQUEST e RESPONSE com mesmo traceId/spanId
 - ✅ **Genérico**: Funciona com Bunyan, Pino, console.log ou qualquer logger
 - ✅ **Centralizado**: Todos os logs no OpenSearch
+- ✅ **Tracing Completo**: Traces exportados via OTLP para Grafana Tempo (opcional)
+
+## 📡 OpenTelemetry Collector
+
+O `azify-logger` inclui um OpenTelemetry Collector configurado para receber traces via OTLP e exportá-los para Grafana Tempo.
+
+### Configuração
+
+Para habilitar o envio de traces, configure a variável de ambiente na sua aplicação:
+
+```bash
+OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318/v1/traces
+```
+
+### URLs
+
+| Ambiente | URL |
+|----------|-----|
+| **Development** | `http://localhost:4318/v1/traces` |
+| **Staging** | `https://logsdashboard.azify.dev/v1/traces` |
+| **Production** | `https://cadence.aztech.host/v1/traces` | 
 
 ## 🔍 Como Funciona
 
@@ -192,11 +228,11 @@ O deploy é feito automaticamente via GitHub Actions.
 
 **Comandos seguros** (preservam dados):
 ```bash
-docker-compose stop
-docker-compose restart
+docker compose stop
+docker compose restart
 ```
 
 **Comandos destrutivos** (APAGAM logs):
 ```bash
-docker-compose down -v  # ⚠️ APAGA VOLUMES!
+docker compose down -v  # ⚠️ APAGA VOLUMES!
 ```

package/index.js

@@ -341,7 +341,8 @@ module.exports.streams = {
 }
 module.exports.middleware = {
   restify: require('./middleware-restify'),
-  express: require('./middleware-express')
+  express: require('./middleware-express'),
+  fastify: require('./middleware-fastify')
 }
 module.exports.startLoggerWorker = require('./queue/workerManager').startLoggerWorker
 module.exports.stopLoggerWorker = require('./queue/workerManager').stopLoggerWorker

package/middleware-express.js

@@ -1,8 +1,63 @@
-const { runWithRequestContext, startRequestContext, getRequestContext } = require('./store')
+const { startRequestContext, runWithRequestContext, getRequestContext } = require('./store')
 const { createHttpLoggerTransport } = require('./streams/httpQueue')
-const { randomUUID } = require('crypto')
+const { Worker } = require('worker_threads')
+const path = require('path')
 const os = require('os')
 
+// Importar OpenTelemetry para sincronizar contexto
+let trace, otelContext
+try {
+  const otelApi = require('@opentelemetry/api')
+  trace = otelApi.trace
+  otelContext = otelApi.context
+} catch (_) {
+  trace = { getSpan: () => null }
+  otelContext = { active: () => ({}) }
+}
+
+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)
+}
+
+function sanitizeTraceHex(value) {
+  if (!value || typeof value !== 'string') return null
+  const hex = value.replace(/[^0-9a-fA-F]/g, '').toLowerCase()
+  if (!hex) return null
+  return hex.padEnd(32, '0').slice(0, 32)
+}
+
+function safeSerializeBody(payload) {
+  if (payload == null) return ''
+  if (typeof payload === 'string') return payload
+  if (Buffer.isBuffer(payload)) return payload.toString('utf8')
+  try {
+    return JSON.stringify(payload)
+  } catch (err) {
+    try {
+      return String(payload)
+    } catch {
+      return ''
+    }
+  }
+}
+
+function normalizeChunkToBuffer(chunk) {
+  if (chunk == null) return null
+  if (Buffer.isBuffer(chunk)) return chunk
+  if (typeof chunk === 'string') return Buffer.from(chunk)
+  if (chunk && chunk.type === 'Buffer' && Array.isArray(chunk.data)) {
+    return Buffer.from(chunk.data)
+  }
+  try {
+    return Buffer.from(String(chunk))
+  } catch {
+    return null
+  }
+}
+
 const HEADER_WHITELIST = new Set([
   'content-type',
   'content-length',
@@ -52,27 +107,52 @@ function createExpressLoggingMiddleware(options = {}) {
 
   const hostname = os.hostname()
   
+  const serviceObj = config.serviceName ? { name: config.serviceName, version: '1.0.0' } : null
+  
+  const workerPool = []
+  const cpuCount = Math.max(1, (os.cpus() || []).length || 1)
+  const WORKER_POOL_SIZE = Math.min(8, Math.max(2, cpuCount))
+  const maxWorkers = Math.min(WORKER_POOL_SIZE, cpuCount)
+  let workerIndex = 0
+  let poolInitialized = false
+  
+  function initWorkerPool() {
+    try {
+      const workerPath = path.join(__dirname, 'utils', 'bodyWorker.js')
+      for (let i = 0; i < maxWorkers; i++) {
+        try {
+          const worker = new Worker(workerPath)
+          workerPool.push(worker)
+        } catch (err) {
+          break
+        }
+      }
+    } catch (err) {
+    }
+  }
+  
+  function ensureWorkerPool() {
+    if (!poolInitialized && (config.captureResponseBody || config.captureRequestBody)) {
+      poolInitialized = true
+      initWorkerPool()
+    }
+  }
+  
+  function getWorker() {
+    if (workerPool.length === 0) return null
+    const worker = workerPool[workerIndex % workerPool.length]
+    workerIndex++
+    return worker
+  }
+  
   function sendLog(level, message, meta = {}) {
     if (!transport || typeof transport.enqueue !== 'function') return
     
-    try {
-      const metaObj = {
-        service: {
-          name: config.serviceName,
-          version: '1.0.0'
-        },
-        environment: config.environment,
-        timestamp: new Date().toISOString(),
-        hostname: hostname,
-        ...meta
-      }
-      
-      transport.enqueue({
-        level,
-        message,
-        meta: metaObj
-      }, { 'content-type': 'application/json' })
-    } catch (err) { }
+    transport.enqueue({
+      level,
+      message,
+      meta
+    }, { 'content-type': 'application/json' })
   }
 
   return function azifyExpressLoggingMiddleware(req, res, next) {
@@ -85,181 +165,211 @@ function createExpressLoggingMiddleware(options = {}) {
     let responseChunkCaptured = false
     let logSent = false
     
-    let requestId, traceId, spanId, parentSpanId, reqCtx, clientIp, query, cachedHeaders
+    let requestId, traceId, spanId, parentSpanId, clientIp, query, cachedHeaders
     let idsCreated = false
     let headersCached = false
+    let reqCtx = null
+    
+    // Função para extrair traceId/spanId do contexto OTEL ativo
+    function getOtelTraceContext() {
+      try {
+        const activeContext = otelContext.active()
+        const span = trace.getSpan(activeContext)
+        if (span) {
+          const spanContext = span.spanContext()
+          if (spanContext && spanContext.traceId && spanContext.spanId) {
+            // Converter traceId de hex para formato UUID
+            const traceHex = spanContext.traceId.replace(/-/g, '')
+            return {
+              traceId: traceHex.length === 32 ? `${traceHex.substring(0, 8)}-${traceHex.substring(8, 12)}-${traceHex.substring(12, 16)}-${traceHex.substring(16, 20)}-${traceHex.substring(20, 32)}` : spanContext.traceId,
+              spanId: spanContext.spanId,
+              parentSpanId: null // OTEL gerencia isso internamente
+            }
+          }
+        }
+      } catch (_) {}
+      return null
+    }
+    
+    // Criar contexto inicial sincronizado com OTEL
+    function ensureRequestContext() {
+      if (reqCtx) return reqCtx
+      
+      // Tentar pegar do OTEL primeiro
+      const otelCtx = getOtelTraceContext()
+      const traceHex = otelCtx ? otelCtx.traceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(req.headers['x-trace-id'])
+      
+      reqCtx = startRequestContext({
+        requestId: req.requestId || fastUUID(),
+        traceHex: traceHex || undefined,
+        parentSpanId: otelCtx?.parentSpanId || req.headers['x-parent-span-id'] || null
+      })
+      
+      // Se OTEL tem contexto, usar os IDs do OTEL
+      if (otelCtx) {
+        reqCtx.traceId = otelCtx.traceId
+        reqCtx.spanId = otelCtx.spanId
+      }
+      
+      return reqCtx
+    }
+    
+    // Garantir que o contexto está disponível e sincronizado com OTEL ANTES de processar
+    const ctx = ensureRequestContext()
+    
+    // Executar a requisição dentro do contexto AsyncLocalStorage
+    // Isso garante que todos os logs intermediários peguem o mesmo traceId
+    runWithRequestContext(ctx, () => {
+      next()
+    })
+    
+    const logWithContext = (level, message, meta) => {
+      // Sempre tentar pegar do OTEL primeiro (mais confiável)
+      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)
+    }
     
     function ensureIds() {
       if (idsCreated) return
       idsCreated = true
       
-      query = req.query
+      query = req.query || null
       
-      const currentCtx = getRequestContext()
-      const headerTraceId = req.headers['x-trace-id']
-      const headerParentSpanId = req.headers['x-parent-span-id']
+      const ctx = ensureRequestContext()
       
-      if (currentCtx?.traceId) {
-        traceId = currentCtx.traceId
-      } else if (headerTraceId) {
-        traceId = headerTraceId
+      // Priorizar OTEL se disponível
+      const otelCtx = getOtelTraceContext()
+      if (otelCtx) {
+        traceId = otelCtx.traceId
+        spanId = otelCtx.spanId
+        parentSpanId = otelCtx.parentSpanId
       } else {
-        traceId = randomUUID()
+        traceId = ctx.traceId
+        spanId = ctx.spanId
+        parentSpanId = ctx.parentSpanId || req.headers['x-parent-span-id'] || null
       }
       
-      parentSpanId = currentCtx?.spanId || headerParentSpanId || null
-      
-      if (!req.requestId) {
-        const singleUUID = randomUUID()
-        requestId = singleUUID
-        spanId = singleUUID.replace(/-/g, '').substring(0, 16)
-      } else {
-        requestId = req.requestId
-        if (requestId.length >= 16) {
-          spanId = requestId.replace(/-/g, '').substring(0, 16)
-        } else if (traceId.length >= 16) {
-          spanId = traceId.replace(/-/g, '').substring(0, 16)
-        } else {
-          spanId = randomUUID().replace(/-/g, '').substring(0, 16)
-        }
-      }
+      requestId = ctx.requestId || req.requestId || fastUUID()
       
       clientIp = req.ip || req.connection?.remoteAddress || req.socket?.remoteAddress || 'unknown'
-      
-      reqCtx = startRequestContext({ requestId, traceId, spanId, parentSpanId })
+      req.requestId = requestId
     }
     
     function ensureHeaders() {
       if (headersCached) return
       headersCached = true
-      cachedHeaders = config.captureHeaders ? pickHeaders(req.headers || {}) : {}
+      if (config.captureHeaders) {
+        cachedHeaders = pickHeaders(req.headers || {})
+      } else {
+        cachedHeaders = {}
+      }
     }
     
+    function emitResponseLog(meta, chunk) {
+      if (!config.captureResponseBody || chunk == null) {
+        logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+        return
+      }
+
+      if (!meta.response) meta.response = {}
+      meta.response.body = safeSerializeBody(chunk)
+      logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+    }
+
     if (config.logRequest) {
-      setImmediate(() => {
-        try {
-          ensureIds()
-          ensureHeaders()
-          const request = {
-            id: requestId,
-            method,
-            url,
-            path,
-            query: query || {},
-            headers: cachedHeaders,
-            ip: clientIp
-          }
-          if (req.body && config.captureRequestBody) {
-            request.body = req.body
-          }
-          sendLog('info', `[REQUEST] ${method} ${url}`, {
-            traceId: reqCtx.traceId,
-            spanId: reqCtx.spanId,
-            parentSpanId: reqCtx.parentSpanId,
-            requestId: requestId,
-            request: request
-          })
-        } catch (err) { }
+      process.nextTick(() => {
+        ensureIds()
+        ensureHeaders()
+        
+        const request = {
+          id: requestId,
+          method,
+          url,
+          path,
+          ip: clientIp
+        }
+        if (query) request.query = query
+        if (config.captureHeaders && cachedHeaders) request.headers = cachedHeaders
+        if (config.captureRequestBody && req.body !== undefined && req.body != null) {
+          request.body = safeSerializeBody(req.body)
+        }
+        
+        const meta = {
+          traceId: reqCtx.traceId,
+          spanId: reqCtx.spanId,
+          parentSpanId: reqCtx.parentSpanId || null,
+          requestId,
+          request,
+          timestamp: Date.now(),
+          hostname
+        }
+        if (serviceObj) meta.service = serviceObj
+        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)
+      }
+      logSent = true
+      
       const result = originalEnd(chunk, encoding)
 
-      setImmediate(() => {
-        if (logSent) return
-        logSent = true
+      if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
+        responseChunk = chunk
+        responseChunkCaptured = true
+      }
+      
+      process.nextTick(() => {
+        ensureIds()
         
-        try {
-          if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
-            responseChunk = chunk
-            responseChunkCaptured = true
-          }
-          
-          ensureIds()
-          
-          const statusCode = res.statusCode || 200
-          const duration = Date.now() - startTime
-          
-          const response = { statusCode, durationMs: duration }
-          if (responseChunk !== null && responseChunkCaptured && config.captureResponseBody) {
-            response.body = responseChunk
-          }
-          
-          if (config.captureHeaders) {
-            ensureHeaders()
-          }
-          
-          const meta = {
-            traceId: reqCtx.traceId,
-            spanId: reqCtx.spanId,
-            parentSpanId: reqCtx.parentSpanId,
-            requestId: requestId,
-            request: {
-              id: requestId,
-              method,
-              url,
-              path,
-              query: query || {},
-              headers: config.captureHeaders ? (cachedHeaders || {}) : {},
-              ip: clientIp
-            },
-            response: response
-          }
-          
-          sendLog('info', `[RESPONSE] ${method} ${url}`, meta)
-        } catch (err) { }
+        const statusCode = res.statusCode || 200
+        const duration = Date.now() - startTime
+        const response = { statusCode, durationMs: duration }
+        
+        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
+        emitResponseLog(meta, chunkToProcess)
       })
       
       return result
     }
-
-    try {
-      next()
-    } catch (err) {
-      if (!logSent) {
-        logSent = true
-        ensureIds()
-        runWithRequestContext(reqCtx, () => {
-          process.stderr.write(`[azify-logger][middleware] Erro no next(): ${err?.message || String(err)}\n`)
-          setImmediate(() => {
-            try {
-              const statusCode = res.statusCode || 500
-              const duration = Date.now() - startTime
-              
-              ensureHeaders()
-              
-              const response = { statusCode, durationMs: duration }
-              const meta = {
-                traceId: reqCtx.traceId,
-                spanId: reqCtx.spanId,
-                parentSpanId: reqCtx.parentSpanId,
-                requestId: requestId,
-                request: {
-                  id: requestId,
-                  method,
-                  url,
-                  path,
-                  query: query || {},
-                  headers: cachedHeaders,
-                  ip: clientIp
-                },
-                response: response,
-                error: {
-                  message: err?.message || String(err),
-                  name: err?.name || 'Error',
-                  stack: err?.stack
-                }
-              }
-              sendLog('error', `[RESPONSE] ${method} ${url}`, meta)
-            } catch (logErr) { }
-          })
-        })
-      }
-      throw err
-    }
   }
 }