azify-logger 1.0.30 → 1.0.31

package/README.md

@@ -205,6 +205,22 @@ curl -X POST http://localhost:3001/log \
 
 Acesse `http://localhost:3002` e faça login com Azure AD.
 
+### Apps fora da mesma máquina / rede (Azure)
+
+Por padrão, o `azify-logger` **só aceita chamadas dos próprios serviços locais** (mesma VM / rede privada).
+
+Se sua aplicação **não estiver rodando na mesma máquina/VM** do `azify-logger`:
+
+- Descubra o **IP público** da aplicação cliente
+- Envie esse IP para que ele seja incluído na configuração interna (`ALLOWED_SOURCE_IPS`)
+
+Isso vale tanto para:
+
+- Envio de logs (`/log` e `/send`)
+- Envio de traces (`/v1/traces`)
+
+Enquanto o IP não for incluído nessa lista, chamadas vindas de fora da mesma máquina/rede serão bloqueadas com `403 Forbidden`.
+
 ## 🚀 Deploy
 
 ### Staging - Deploy Automático
@@ -222,6 +238,102 @@ O deploy é feito automaticamente via GitHub Actions.
 3. Configure: **Environment:** `production`
 4. Clique em **Run workflow**
 
+## 📦 Retenção e Arquivamento de Logs
+
+> **⚠️ Importante**: A retenção é configurada **apenas no servidor `azify-logger`**. As aplicações que usam a lib **não precisam se preocupar** com retenção - elas apenas enviam logs normalmente.
+
+O `azify-logger` inclui um sistema automático de retenção que:
+
+- ✅ **Mantém sempre os últimos 30 dias** de logs disponíveis no OpenSearch para consulta imediata
+- ✅ **Compacta e arquiva** logs mais antigos automaticamente
+- ✅ **Envia para Azure Blob Storage** para armazenamento de longo prazo
+- ✅ **Remove logs antigos** do OpenSearch após arquivamento bem-sucedido
+
+### Como Funciona
+
+1. **Agendamento**: O serviço de retenção executa automaticamente 1x por dia às 3h da manhã (configurável via `RETENTION_RUN_AT_HOUR`)
+2. **Identificação**: Busca todos os logs com mais de 30 dias no OpenSearch
+3. **Arquivamento**:
+   - Exporta logs mais antigos que 30 dias
+   - Compacta em formato ZIP
+   - Envia para Azure Blob Storage na estrutura `logs/{app}/{YYYYMM}/{DD}/`
+   - Remove do OpenSearch após confirmação de upload bem-sucedido
+
+### Configuração (Apenas no Servidor azify-logger)
+
+A configuração de retenção é feita **apenas no servidor `azify-logger`**, no arquivo `env/app.env`:
+
+```bash
+RETENTION_DAYS=30                    # Dias de logs mantidos no OpenSearch (padrão: 30)
+RETENTION_RUN_AT_HOUR=3              # Horário de execução diária (0-23, padrão: 3h da manhã)
+
+**⚠️ As aplicações que usam a lib `azify-logger` não precisam configurar nada relacionado à retenção.**
+
+### Execução Manual
+
+Para executar a retenção manualmente (útil para testes):
+
+```bash
+# Executar uma vez
+npm run retention -- --once
+
+# Ou via Docker
+docker exec azify-retention-manager node scripts/retention-manager.js --once
+```
+
+### Estrutura no Blob Storage
+
+Os arquivos são organizados da seguinte forma:
+
+```
+{container}/
+  └── logs/
+      └── {YYYYMM}/  (ex: 202512/)
+          └── log-YYYY-MM-DD-HH-MM-SS-UUID.zip
+```
+
+Cada arquivo ZIP contém:
+- `metadata.json`: Metadados do índice (nome, data de exportação, contagem de documentos, dias de retenção)
+- `{indexName}-{timestamp}.json`: Todos os documentos exportados em JSON
+
+O sistema sempre mantém **os últimos 30 dias** de logs disponíveis no OpenSearch/Grafana.
+
+### Scripts Úteis
+
+#### Consulta e Validação de Blob Storage
+
+```bash
+# Listar todos os arquivos no blob storage
+npm run list:blob
+
+# Listar arquivos ZIP recentes (última hora)
+npm run list:blob:recent
+
+# Baixar um arquivo ZIP específico
+npm run download:blob "logs/harmony/202512/05/log-2025-12-05-14-29-01.zip" ~/Downloads
+
+# Baixar todos os arquivos de uma pasta
+npm run download:blob "logs/harmony/202512/05/*" ~/Downloads
+```
+
+#### Reimportação de Logs
+
+Para reimportar logs arquivados de volta para o OpenSearch (útil para análise de logs antigos):
+
+```bash
+# Reimportar um arquivo ZIP específico
+npm run reimport:logs ~/Downloads/log-2025-12-05-18-31-32.zip
+
+# Reimportar todos os ZIPs de uma pasta
+npm run reimport:logs ~/Downloads/arquivos-exportados/
+```
+
+**Importante:**
+- Os logs serão reimportados no índice original
+- Os timestamps originais são preservados
+- A aplicação já deve estar configurada no Grafana (organização e datasource)
+- Após a reimportação, os logs estarão disponíveis no Grafana imediatamente
+
 ## ⚠️ Preservação de Dados
 
 **IMPORTANTE:** Logs do OpenSearch são armazenados em volume Docker persistente.

package/middleware-express.js

@@ -4,7 +4,6 @@ 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')
@@ -170,7 +169,6 @@ function createExpressLoggingMiddleware(options = {}) {
     let headersCached = false
     let reqCtx = null
     
-    // Função para extrair traceId/spanId do contexto OTEL ativo
     function getOtelTraceContext() {
       try {
         const activeContext = otelContext.active()
@@ -178,12 +176,11 @@ function createExpressLoggingMiddleware(options = {}) {
         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
+              parentSpanId: null
             }
           }
         }
@@ -191,11 +188,9 @@ function createExpressLoggingMiddleware(options = {}) {
       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'])
       
@@ -205,7 +200,6 @@ function createExpressLoggingMiddleware(options = {}) {
         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
@@ -214,17 +208,13 @@ function createExpressLoggingMiddleware(options = {}) {
       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()
       
@@ -242,7 +232,6 @@ function createExpressLoggingMiddleware(options = {}) {
       
       const ctx = ensureRequestContext()
       
-      // Priorizar OTEL se disponível
       const otelCtx = getOtelTraceContext()
       if (otelCtx) {
         traceId = otelCtx.traceId

package/middleware-fastify.js

@@ -1,7 +1,17 @@
-const { startRequestContext } = require('./store')
+const { startRequestContext, runWithRequestContext, getRequestContext } = require('./store')
 const { createHttpLoggerTransport } = require('./streams/httpQueue')
 const os = require('os')
 
+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)
@@ -92,6 +102,50 @@ function createFastifyLoggingPlugin(options = {}) {
 
   return async function azifyFastifyPlugin(fastify, opts) {
     fastify.addHook('onRequest', async (request, reply) => {
+      let reqCtx = null
+      
+      function getOtelTraceContext() {
+        try {
+          const activeContext = otelContext.active()
+          const span = trace.getSpan(activeContext)
+          if (span) {
+            const spanContext = span.spanContext()
+            if (spanContext && spanContext.traceId && spanContext.spanId) {
+              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
+              }
+            }
+          }
+        } catch (_) {}
+        return null
+      }
+      
+      function ensureRequestContext() {
+        if (reqCtx) return reqCtx
+        
+        const otelCtx = getOtelTraceContext()
+        const traceHex = otelCtx ? otelCtx.traceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(request.headers['x-trace-id'])
+        
+        reqCtx = startRequestContext({
+          requestId: request.requestId || fastUUID(),
+          traceHex: traceHex || undefined,
+          parentSpanId: otelCtx?.parentSpanId || request.headers['x-parent-span-id'] || null
+        })
+        
+        if (otelCtx) {
+          reqCtx.traceId = otelCtx.traceId
+          reqCtx.spanId = otelCtx.spanId
+        }
+        
+        return reqCtx
+      }
+      
+      const ctx = ensureRequestContext()
+      
+      runWithRequestContext(ctx, () => {})
       const startTime = Date.now()
       const method = request.method
       const url = request.url
@@ -104,20 +158,14 @@ function createFastifyLoggingPlugin(options = {}) {
       let requestId, traceId, spanId, parentSpanId, clientIp, query, cachedHeaders
       let idsCreated = false
       let headersCached = false
-      let reqCtx = null
       
       const logWithContext = (level, message, meta) => {
-        if (!reqCtx) {
-          const traceHex = sanitizeTraceHex(request.headers['x-trace-id'])
-          reqCtx = startRequestContext({
-            requestId: requestId || request.requestId || fastUUID(),
-            traceHex,
-            parentSpanId: request.headers['x-parent-span-id'] || null
-          })
-        }
-        meta.traceId = meta.traceId || reqCtx.traceId
-        meta.spanId = meta.spanId || reqCtx.spanId
-        meta.parentSpanId = meta.parentSpanId || reqCtx.parentSpanId
+        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)
       }
       
@@ -127,20 +175,20 @@ function createFastifyLoggingPlugin(options = {}) {
         
         query = request.query || null
         
-        if (!reqCtx) {
-          const traceHex = sanitizeTraceHex(request.headers['x-trace-id'])
-          reqCtx = startRequestContext({
-            requestId: request.requestId || fastUUID(),
-            traceHex,
-            parentSpanId: request.headers['x-parent-span-id'] || null
-          })
-        }
+        const ctx = ensureRequestContext()
         
-        requestId = reqCtx.requestId || request.requestId || fastUUID()
-        traceId = reqCtx.traceId
-        spanId = reqCtx.spanId
-        parentSpanId = reqCtx.parentSpanId || request.headers['x-parent-span-id'] || null
+        const otelCtx = getOtelTraceContext()
+        if (otelCtx) {
+          traceId = otelCtx.traceId
+          spanId = otelCtx.spanId
+          parentSpanId = otelCtx.parentSpanId
+        } else {
+          traceId = ctx.traceId
+          spanId = ctx.spanId
+          parentSpanId = ctx.parentSpanId || request.headers['x-parent-span-id'] || null
+        }
         
+        requestId = ctx.requestId || request.requestId || fastUUID()
         clientIp = request.ip || request.socket?.remoteAddress || 'unknown'
         request.requestId = requestId
       }
@@ -204,10 +252,13 @@ function createFastifyLoggingPlugin(options = {}) {
             requestObj.body = safeSerializeBody(request.body)
           }
           
+          const otelCtx = getOtelTraceContext()
+          const ctx = getRequestContext() || ensureRequestContext()
+          
           const meta = {
-            traceId: reqCtx.traceId,
-            spanId: reqCtx.spanId,
-            parentSpanId: reqCtx.parentSpanId || null,
+            traceId: otelCtx?.traceId || ctx.traceId,
+            spanId: otelCtx?.spanId || ctx.spanId,
+            parentSpanId: otelCtx?.parentSpanId || ctx.parentSpanId || null,
             requestId,
             request: requestObj,
             timestamp: Date.now(),
@@ -240,20 +291,53 @@ function createFastifyLoggingPlugin(options = {}) {
       let requestId, traceId, spanId, parentSpanId, clientIp, query, cachedHeaders
       let idsCreated = false
       let headersCached = false
-      let reqCtx = null
       
-      const logWithContext = (level, message, meta) => {
-        if (!reqCtx) {
-          const traceHex = sanitizeTraceHex(request.headers['x-trace-id'])
-          reqCtx = startRequestContext({
-            requestId: requestId || request.requestId || fastUUID(),
-            traceHex,
-            parentSpanId: request.headers['x-parent-span-id'] || null
-          })
+      function getOtelTraceContext() {
+        try {
+          const activeContext = otelContext.active()
+          const span = trace.getSpan(activeContext)
+          if (span) {
+            const spanContext = span.spanContext()
+            if (spanContext && spanContext.traceId && spanContext.spanId) {
+              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
+              }
+            }
+          }
+        } catch (_) {}
+        return null
+      }
+      
+      function ensureRequestContext() {
+        if (reqCtx) return reqCtx
+        
+        const otelCtx = getOtelTraceContext()
+        const traceHex = otelCtx ? otelCtx.traceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(request.headers['x-trace-id'])
+        
+        reqCtx = startRequestContext({
+          requestId: request.requestId || fastUUID(),
+          traceHex: traceHex || undefined,
+          parentSpanId: otelCtx?.parentSpanId || request.headers['x-parent-span-id'] || null
+        })
+        
+        if (otelCtx) {
+          reqCtx.traceId = otelCtx.traceId
+          reqCtx.spanId = otelCtx.spanId
         }
-        meta.traceId = meta.traceId || reqCtx.traceId
-        meta.spanId = meta.spanId || reqCtx.spanId
-        meta.parentSpanId = meta.parentSpanId || reqCtx.parentSpanId
+        
+        return reqCtx
+      }
+      
+      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
         sendLog(level, message, meta)
       }
       
@@ -263,20 +347,20 @@ function createFastifyLoggingPlugin(options = {}) {
         
         query = request.query || null
         
-        if (!reqCtx) {
-          const traceHex = sanitizeTraceHex(request.headers['x-trace-id'])
-          reqCtx = startRequestContext({
-            requestId: request.requestId || fastUUID(),
-            traceHex,
-            parentSpanId: request.headers['x-parent-span-id'] || null
-          })
-        }
+        const ctx = ensureRequestContext()
         
-        requestId = reqCtx.requestId || request.requestId || fastUUID()
-        traceId = reqCtx.traceId
-        spanId = reqCtx.spanId
-        parentSpanId = reqCtx.parentSpanId || request.headers['x-parent-span-id'] || null
+        const otelCtx = getOtelTraceContext()
+        if (otelCtx) {
+          traceId = otelCtx.traceId
+          spanId = otelCtx.spanId
+          parentSpanId = otelCtx.parentSpanId
+        } else {
+          traceId = ctx.traceId
+          spanId = ctx.spanId
+          parentSpanId = ctx.parentSpanId || request.headers['x-parent-span-id'] || null
+        }
         
+        requestId = ctx.requestId || request.requestId || fastUUID()
         clientIp = request.ip || request.socket?.remoteAddress || 'unknown'
       }
       
@@ -322,10 +406,13 @@ function createFastifyLoggingPlugin(options = {}) {
         if (query) requestObj.query = query
         if (config.captureHeaders && cachedHeaders) requestObj.headers = cachedHeaders
         
+        const otelCtx = getOtelTraceContext()
+        const ctx = getRequestContext() || ensureRequestContext()
+        
         const meta = {
-          traceId: reqCtx.traceId,
-          spanId: reqCtx.spanId,
-          parentSpanId: reqCtx.parentSpanId || null,
+          traceId: otelCtx?.traceId || ctx.traceId,
+          spanId: otelCtx?.spanId || ctx.spanId,
+          parentSpanId: otelCtx?.parentSpanId || ctx.parentSpanId || null,
           requestId,
           request: requestObj,
           response,

package/middleware-restify.js

@@ -1,7 +1,17 @@
-const { startRequestContext } = require('./store')
+const { startRequestContext, runWithRequestContext, getRequestContext } = require('./store')
 const { createHttpLoggerTransport } = require('./streams/httpQueue')
 const os = require('os')
 
+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)
@@ -78,18 +88,54 @@ function createRestifyLoggingMiddleware (options = {}) {
 
   return function azifyLoggingMiddleware (req, res, next) {
     const startTime = Date.now()
-    const requestId = req.requestId || fastUUID()
 
     if (res._azifySetup) {
       return next()
     }
     res._azifySetup = true
 
-    const traceHex = sanitizeTraceHex(req.headers['x-trace-id'])
-    const reqCtx = startRequestContext({
-      requestId,
-      traceHex,
-      parentSpanId: req.headers['x-parent-span-id'] || null
+    function getOtelTraceContext() {
+      try {
+        const activeContext = otelContext.active()
+        const span = trace.getSpan(activeContext)
+        if (span) {
+          const spanContext = span.spanContext()
+          if (spanContext && spanContext.traceId && spanContext.spanId) {
+            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
+            }
+          }
+        }
+      } catch (_) {}
+      return null
+    }
+    
+    function ensureRequestContext() {
+      const otelCtx = getOtelTraceContext()
+      const traceHex = otelCtx ? otelCtx.traceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(req.headers['x-trace-id'])
+      
+      const reqCtx = startRequestContext({
+        requestId: req.requestId || fastUUID(),
+        traceHex: traceHex || undefined,
+        parentSpanId: otelCtx?.parentSpanId || req.headers['x-parent-span-id'] || null
+      })
+      
+      if (otelCtx) {
+        reqCtx.traceId = otelCtx.traceId
+        reqCtx.spanId = otelCtx.spanId
+      }
+      
+      return reqCtx
+    }
+    
+    const reqCtx = ensureRequestContext()
+    const requestId = reqCtx.requestId
+    
+    runWithRequestContext(reqCtx, () => {
+      next()
     })
 
     let normalizedPath = req.url
@@ -143,11 +189,14 @@ function createRestifyLoggingMiddleware (options = {}) {
         const duration = Date.now() - startTime
         const statusCode = responseStatus || res.statusCode || 200
         const responseHeaders = typeof res.getHeaders === 'function' ? res.getHeaders() : {}
+        
+        const otelCtx = getOtelTraceContext()
+        const ctx = getRequestContext() || reqCtx
 
         const meta = {
-          traceId: reqCtx.traceId,
-          spanId: reqCtx.spanId,
-          parentSpanId: reqCtx.parentSpanId || null,
+          traceId: otelCtx?.traceId || ctx.traceId,
+          spanId: otelCtx?.spanId || ctx.spanId,
+          parentSpanId: otelCtx?.parentSpanId || ctx.parentSpanId || null,
           requestId,
           request: requestSnapshot,
           response: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.30",
+  "version": "1.0.31",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -17,7 +17,18 @@
     "docker:up": "docker-compose up -d",
     "docker:down": "docker-compose down",
     "docker:logs": "docker-compose logs -f",
-    "worker": "node scripts/redis-worker.js"
+    "worker": "node scripts/redis-worker.js",
+    "validate:retention": "node scripts/validate-retention.js",
+    "inspect:zip": "node scripts/inspect-zip.js",
+    "retention": "node scripts/retention-manager.js",
+    "list:blob": "node scripts/list-blob-files.js",
+    "list:blob:recent": "node scripts/download-blob-zip.js",
+    "check:old-logs": "node scripts/check-old-logs.js",
+    "validate:blob": "node scripts/validate-blob-zip.js",
+    "validate:blob:keep": "KEEP_VALIDATION_FILES=true node scripts/validate-blob-zip.js",
+    "download:blob": "node scripts/download-blob-zip.js",
+    "reimport:logs": "node scripts/reimport-logs.js",
+    "check:server-time": "node -e \"const now = new Date(); const tz = Intl.DateTimeFormat().resolvedOptions().timeZone; console.log('🕐 Hora do servidor:', now.toLocaleString('pt-BR', {timeZone: tz})); console.log('🌍 Timezone:', tz); console.log('🕐 Hora em São Paulo:', now.toLocaleString('pt-BR', {timeZone: 'America/Sao_Paulo'})); console.log('\\n💡 Configure RETENTION_RUN_AT_HOUR com a hora do servidor (0-23)');\""
   },
   "keywords": [
     "logging",
@@ -28,6 +39,7 @@
   "author": "Azify",
   "license": "MIT",
   "dependencies": {
+    "@azure/storage-blob": "^12.17.0",
     "@opentelemetry/api": "1.0.4",
     "@opentelemetry/auto-instrumentations-node": "0.27.0",
     "@opentelemetry/core": "1.0.1",
@@ -38,6 +50,8 @@
     "@opentelemetry/resources": "1.0.1",
     "@opentelemetry/sdk-node": "0.27.0",
     "@opentelemetry/semantic-conventions": "1.0.1",
+    "adm-zip": "^0.5.16",
+    "archiver": "^6.0.1",
     "axios": "^1.6.0",
     "cors": "^2.8.5",
     "express": "^4.18.2",

package/register.js

@@ -580,68 +580,143 @@ try {
 
         instance.interceptors.response.use(
           (response) => {
-            const url = buildUrl(response.config)
-            const testMeta = { url }
-            if (isLoggerApiCall(testMeta)) {
-              return response
-            }
+            try {
+              if (!response || !response.config) {
+                return response
+              }
 
-            const marker = response.config?.__azifyLogger
-            const childCtx = response.config?.__azifyChildCtx
+              const url = buildUrl(response.config) || response.config?.url || response.request?.responseURL || 'unknown'
+              const testMeta = { url }
+              if (isLoggerApiCall(testMeta)) {
+                return response
+              }
 
-            if (marker && marker.meta) {
-              const duration = Number((performance.now() - marker.start).toFixed(2))
+              const marker = response.config?.__azifyLogger
+              const method = (response.config?.method || 'get').toUpperCase()
+              const requestHeaders = response.config?.headers || {}
+              const hasTraceHeaders = !!(requestHeaders['x-trace-id'] || requestHeaders['X-Trace-ID'] || requestHeaders['x-span-id'] || requestHeaders['X-Span-ID'])
               const shouldLogResponse =
                 HTTP_CLIENT_MODE === 'all' ||
                 (HTTP_CLIENT_MODE === 'errors' && response.status >= 400)
 
-              if (shouldLogResponse) {
-                const meta = {
-                  ...marker.meta,
-                  statusCode: response.status,
-                  responseTimeMs: duration,
-                  responseHeaders: response.headers,
-                  responseBody: response.data
+              if (shouldLogResponse || hasTraceHeaders) {
+                const finalUrl = (url && url !== 'unknown') ? url : (marker?.meta?.url || response.config?.url || response.request?.responseURL || url)
+                
+                if (finalUrl && finalUrl !== 'unknown') {
+                let meta
+                let duration = 0
+                
+                if (marker && marker.meta) {
+                  duration = Number((performance.now() - marker.start).toFixed(2))
+                  meta = {
+                    ...marker.meta,
+                    url: finalUrl,
+                    statusCode: response.status,
+                    responseTimeMs: duration,
+                    responseHeaders: response.headers,
+                    responseBody: response.data
+                  }
+                } else {
+                  const requestHeaders = response.config?.headers || {}
+                  const ctx = getRequestContext()
+                  const traceId = requestHeaders['x-trace-id'] || requestHeaders['X-Trace-ID'] || ctx?.traceId || randomUUID()
+                  const spanId = requestHeaders['x-span-id'] || requestHeaders['X-Span-ID'] || randomBytes(8).toString('hex')
+                  const parentSpanId = requestHeaders['x-parent-span-id'] || requestHeaders['X-Parent-Span-ID'] || ctx?.spanId || null
+                  const requestId = requestHeaders['x-request-id'] || requestHeaders['X-Request-ID'] || ctx?.requestId || randomUUID()
+                  
+                  meta = {
+                    traceId,
+                    spanId,
+                    parentSpanId,
+                    requestId,
+                    method,
+                    url: finalUrl,
+                    statusCode: response.status,
+                    responseTimeMs: duration,
+                    responseHeaders: response.headers,
+                    responseBody: response.data
+                  }
                 }
                 
                 markSource(meta, 'http-client')
-                const message = `[RESPONSE] ${meta.method} ${meta.url} ${response.status} ${duration}ms`
+                const message = `[RESPONSE] ${meta.method} ${meta.url} ${response.status} ${meta.responseTimeMs}ms`
                 const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
                 
                 sendOutboundLog(level, message, meta)
+                }
               }
+            } catch (err) {
             }
 
             return response
           },
           (error) => {
-            const config = error?.config
-            if (config) {
-              const url = buildUrl(config)
-              const testMeta = { url }
-              if (isLoggerApiCall(testMeta)) {
-                return Promise.reject(error)
+            try {
+              const config = error?.config
+              if (config) {
+                const url = buildUrl(config)
+                const testMeta = { url }
+                if (isLoggerApiCall(testMeta)) {
+                  return Promise.reject(error)
+                }
               }
-            }
 
-            const marker = config?.__azifyLogger
-            const childCtx = config?.__azifyChildCtx
-
-            if (marker && marker.meta) {
-              const duration = Number((performance.now() - marker.start).toFixed(2))
-              const meta = {
-                ...marker.meta,
-                responseTimeMs: duration,
-                error: {
-                  name: error?.name || 'Error',
-                  message: error?.message || String(error),
-                  stack: error?.stack
+              const marker = config?.__azifyLogger
+              const method = (config?.method || 'get').toUpperCase()
+              const url = config ? buildUrl(config) : (error?.request?.responseURL || error?.config?.url || 'unknown')
+              const shouldLogError = HTTP_CLIENT_MODE === 'all' || HTTP_CLIENT_MODE === 'errors'
+
+              if (shouldLogError && url && url !== 'unknown') {
+                let meta
+                let duration = 0
+                
+                if (marker && marker.meta) {
+                  duration = Number((performance.now() - marker.start).toFixed(2))
+                  meta = {
+                    ...marker.meta,
+                    responseTimeMs: duration,
+                    error: {
+                      name: error?.name || 'Error',
+                      message: error?.message || String(error),
+                      stack: error?.stack,
+                      code: error?.code,
+                      status: error?.response?.status,
+                      statusText: error?.response?.statusText
+                    }
+                  }
+                } else {
+                  const requestHeaders = config?.headers || {}
+                  const ctx = getRequestContext()
+                  const traceId = requestHeaders['x-trace-id'] || requestHeaders['X-Trace-ID'] || ctx?.traceId || randomUUID()
+                  const spanId = requestHeaders['x-span-id'] || requestHeaders['X-Span-ID'] || randomBytes(8).toString('hex')
+                  const parentSpanId = requestHeaders['x-parent-span-id'] || requestHeaders['X-Parent-Span-ID'] || ctx?.spanId || null
+                  const requestId = requestHeaders['x-request-id'] || requestHeaders['X-Request-ID'] || ctx?.requestId || randomUUID()
+                  
+                  meta = {
+                    traceId,
+                    spanId,
+                    parentSpanId,
+                    requestId,
+                    method,
+                    url,
+                    responseTimeMs: duration,
+                    error: {
+                      name: error?.name || 'Error',
+                      message: error?.message || String(error),
+                      stack: error?.stack,
+                      code: error?.code,
+                      status: error?.response?.status,
+                      statusText: error?.response?.statusText
+                    }
+                  }
                 }
+                
+                markSource(meta, 'http-client')
+                const message = `[ERROR] ${meta.method} ${meta.url}`
+                
+                sendOutboundLog('error', message, meta)
               }
-              markSource(meta, 'http-client')
-              const message = `[ERROR] ${meta.method} ${meta.url}`
-              
-              sendOutboundLog('error', message, meta)
+            } catch (err) {
             }
 
             return Promise.reject(error)
@@ -735,18 +810,19 @@ try {
             })
 
             const duration = Number((performance.now() - start).toFixed(2))
+            const hasTraceHeaders = !!(requestMeta.traceId && requestMeta.spanId)
             const shouldLogResponse =
               HTTP_CLIENT_MODE === 'all' ||
-              (HTTP_CLIENT_MODE === 'errors' && response.status >= 400)
+              (HTTP_CLIENT_MODE === 'errors' && response.status >= 400) ||
+              hasTraceHeaders
 
             if (shouldLogResponse) {
-              (async () => {
+              const logResponse = async () => {
+                let responseBody = null
+                const contentType = response.headers.get('content-type') || ''
+                
                 try {
                   const clonedResponse = response.clone()
-                  const contentType = response.headers.get('content-type') || ''
-                  
-                  let responseBody = null
-                  
                   if (contentType.includes('application/json') || contentType.includes('text/')) {
                     const bodyText = await clonedResponse.text()
                     if (contentType.includes('application/json')) {
@@ -759,7 +835,26 @@ try {
                       responseBody = bodyText
                     }
                   }
+                } catch (cloneError) {
+                  try {
+                    if (contentType.includes('application/json') || contentType.includes('text/')) {
+                      const bodyText = await response.text()
+                      if (contentType.includes('application/json')) {
+                        try {
+                          responseBody = JSON.parse(bodyText)
+                        } catch (_) {
+                          responseBody = bodyText
+                        }
+                      } else {
+                        responseBody = bodyText
+                      }
+                    }
+                  } catch (_) {
+                    responseBody = null
+                  }
+                }
 
+                try {
                   const responseMeta = {
                     ...requestMeta,
                     statusCode: response.status,
@@ -773,21 +868,27 @@ try {
                   
                   const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
                   sendOutboundLog(level, message, responseMeta)
-                } catch (_) {
-                  const responseMeta = {
-                    ...requestMeta,
-                    statusCode: response.status,
-                    responseTimeMs: duration,
-                    responseHeaders: Object.fromEntries(response.headers.entries()),
-                    responseBody: null
+                } catch (err) {
+                  try {
+                    const responseMeta = {
+                      ...requestMeta,
+                      statusCode: response.status,
+                      responseTimeMs: duration,
+                      responseHeaders: Object.fromEntries(response.headers.entries()),
+                      responseBody: null
+                    }
+                    
+                    markSource(responseMeta, 'http-client')
+                    const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
+                    
+                    const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
+                    sendOutboundLog(level, message, responseMeta)
+                  } catch (_) {
                   }
-                  
-                  markSource(responseMeta, 'http-client')
-                  const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
-                  const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
-                  sendOutboundLog(level, message, responseMeta)
                 }
-              })()
+              }
+              
+              logResponse().catch(() => {})
             }
 
             return response

package/scripts/redis-worker.js

@@ -81,6 +81,15 @@ process.on('uncaughtException', (err) => {
 })
 
 process.on('unhandledRejection', (reason) => {
+  const errMsg = String(reason && reason.message ? reason.message : reason)
+  const errCode = String(reason && reason.code ? reason.code : '')
+  
+  if (errMsg.includes('BUSYGROUP') ||
+      errMsg.includes('Consumer Group name already exists') ||
+      errCode === 'BUSYGROUP' ||
+      (reason && reason.command && reason.command.name === 'xgroup' && reason.command.args && reason.command.args[0] === 'CREATE' && errMsg.includes('already exists'))) {
+    return
+  }
   console.error('[azify-logger][worker] unhandledRejection:', reason)
   process.exit(1)
 })
@@ -89,9 +98,16 @@ async function ensureGroup() {
   try {
     await redis.xgroup('CREATE', STREAM_KEY, WORKER_GROUP, '0', 'MKSTREAM')
   } catch (err) {
-    if (!String(err && err.message).includes('BUSYGROUP')) {
-      throw err
+    const errMsg = String(err && err.message ? err.message : err)
+    const errCode = String(err && err.code ? err.code : '')
+    
+    if (errMsg.includes('BUSYGROUP') ||
+        errMsg.includes('Consumer Group name already exists') ||
+        errCode === 'BUSYGROUP' ||
+        (err && err.command && err.command.name === 'xgroup' && err.command.args && err.command.args[0] === 'CREATE' && errMsg.includes('already exists'))) {
+      return
     }
+    throw err
   }
 }
 
@@ -355,16 +371,17 @@ async function consumeLoop() {
         consecutiveNoGroupErrors = 0
       } catch (err) {
         const errMsg = err && err.message ? err.message : String(err)
-        if (!errMsg.includes('BUSYGROUP')) {
-          const now = Date.now()
-          if (now - lastRedisErrorLog > 5000) {
-            console.error('[azify-logger][worker] erro ao garantir grupo:', errMsg)
-            lastRedisErrorLog = now
-          }
-          await sleep(1000)
-        } else {
+        if (errMsg.includes('BUSYGROUP') || errMsg.includes('Consumer Group name already exists')) {
           groupEnsured = true
+          consecutiveNoGroupErrors = 0
+          continue
+        }
+        const now = Date.now()
+        if (now - lastRedisErrorLog > 5000) {
+          console.error('[azify-logger][worker] erro ao garantir grupo:', errMsg)
+          lastRedisErrorLog = now
         }
+        await sleep(1000)
         continue
       }
     }
@@ -434,6 +451,15 @@ ensureGroup()
     return consumeLoop()
   })
   .catch((err) => {
-    console.error('[azify-logger][worker] não foi possível iniciar:', err)
+    const errMsg = err && err.message ? err.message : String(err)
+    if (errMsg.includes('BUSYGROUP') || errMsg.includes('Consumer Group name already exists')) {
+      console.log('[azify-logger][worker] Consumer Group já existe, continuando...')
+      console.log('[azify-logger][worker] consumindo stream', STREAM_KEY, 'como', CONSUMER_NAME)
+      if (process.send) {
+        process.send({ type: 'azify-logger:ready', pid: process.pid, stream: STREAM_KEY })
+      }
+      return consumeLoop()
+    }
+    console.error('[azify-logger][worker] não foi possível iniciar:', errMsg)
     process.exit(1)
   })

package/server.js

@@ -72,7 +72,7 @@ function isPrivateOrLocalhost(ip) {
 }
 
 function validateNetworkAccess(req, res, next) {
-  if (req.path === '/health' || req.path === '/') {
+  if (req.path === '/health' || req.path === '/' || req.path === '/v1/traces') {
     return next()
   }
   
@@ -385,6 +385,7 @@ async function setupGrafanaForApp(appName) {
     console.log(`[setupGrafana] 📊 Criando datasource para ${appName}...`)
     
     const datasourceUid = `opensearch-${appName.toLowerCase()}`
+    const indexName = `logs-${appName}`
     const datasourceConfig = {
       name: `OpenSearch-${appName}`,
       type: 'grafana-opensearch-datasource',
@@ -393,8 +394,8 @@ async function setupGrafanaForApp(appName) {
       uid: datasourceUid,
       isDefault: true,
       jsonData: {
-        index: `logs-${appName}`,
-        database: `logs-${appName}`,
+        index: indexName,
+        database: indexName,
         timeField: '@timestamp',
         esVersion: '2.11.1',
         version: '2.11.1',
@@ -481,7 +482,6 @@ async function setupGrafanaForApp(appName) {
       }
     }
 
-    // Datasource Grafana Tempo para tracing completo (opcional - não bloqueia criação da org)
     try {
       const tempoDatasourceUid = `tempo-${appName.toLowerCase()}`
       const tempoUrl = runningInDocker ? 'http://azify-tempo:3200' : 'http://localhost:3200'
@@ -949,6 +949,19 @@ async function handleLog(req, res) {
     message = decodeHtmlEntities(message)
   }
 
+  const requestPath = meta?.request?.path || meta?.request?.url || meta?.request?.baseUrl || meta?.url || meta?.path || ''
+  const requestPathLower = String(requestPath).toLowerCase()
+  const messageLower = String(message).toLowerCase()
+  
+  const isSwaggerPath = (
+    requestPathLower.includes('/api-docs') ||
+    requestPathLower.includes('/swagger-ui') ||
+    requestPathLower.includes('/swagger.json') ||
+    requestPathLower.includes('/swagger.yaml') ||
+    requestPathLower.includes('/swagger.yml') ||
+    (requestPathLower.includes('/favicon') && (requestPathLower.includes('/api-docs') || requestPathLower.includes('/swagger')))
+  )
+
   const shouldFilterLog = (
     message.includes('prisma:query') ||
     message.includes('prisma:info') ||
@@ -958,11 +971,21 @@ async function handleLog(req, res) {
     message.includes('UPDATE `') ||
     message.includes('DELETE `') ||
     message.includes('%s: %s') ||
-    message.includes('Application Startup Time')
+    message.includes('Application Startup Time') ||
+    (isSwaggerPath && (
+      messageLower.includes('swaggerdoc') ||
+      messageLower.includes('"openapi"') ||
+      messageLower.includes('swagger-ui-bundle') ||
+      messageLower.includes('swagger-ui-standalone') ||
+      messageLower.includes('swagger-ui.css') ||
+      messageLower.includes('[request]') ||
+      messageLower.includes('[response]') ||
+      requestPathLower.includes('/favicon')
+    ))
   )
 
   if (shouldFilterLog) {
-    return res.json({ success: true, message: 'Log filtrado (Prisma verboso)' })
+    return res.json({ success: true, message: 'Log filtrado' })
   }
 
   const requestId = meta && meta.requestId
@@ -1188,6 +1211,26 @@ async function handleLog(req, res) {
 }
 
 app.post('/log', (req, res) => handleLog(req, res))
+
+app.post('/v1/traces', async (req, res) => {
+  try {
+    const collectorUrl = process.env.OTEL_COLLECTOR_URL || 'http://localhost:4318'
+    const response = await axios.post(`${collectorUrl}/v1/traces`, req.body, {
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      data: req.body,
+      timeout: 30000
+    })
+    res.status(response.status).json(response.data)
+  } catch (err) {
+    if (err.response) {
+      res.status(err.response.status).json(err.response.data)
+    } else {
+      res.status(500).json({ error: err.message })
+    }
+  }
+})
 app.post('/send', (req, res) => handleLog(req, res))
 
 const port = process.env.PORT || 3001