azify-logger 1.0.29 → 1.0.31

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,6 +482,89 @@ async function setupGrafanaForApp(appName) {
       }
     }
 
+    try {
+      const tempoDatasourceUid = `tempo-${appName.toLowerCase()}`
+      const tempoUrl = runningInDocker ? 'http://azify-tempo:3200' : 'http://localhost:3200'
+      const tempoDatasourceConfig = {
+        name: `Tempo-${appName}`,
+        type: 'tempo',
+        access: 'proxy',
+        url: tempoUrl,
+        uid: tempoDatasourceUid,
+        isDefault: false,
+        jsonData: {
+          httpMethod: 'GET',
+          tracesToLogs: {
+            datasourceUid: datasourceUid,
+            tags: ['job', 'service', 'pod'],
+            mappedTags: [{ key: 'service.name', value: 'service' }],
+            mapTagNamesEnabled: false,
+            spanStartTimeShift: '1h',
+            spanEndTimeShift: '1h',
+            filterByTraceID: false,
+            filterBySpanID: false
+          },
+          serviceMap: {
+            datasourceUid: datasourceUid
+          },
+          nodeGraph: {
+            enabled: true
+          },
+          search: {
+            hide: false
+          }
+        },
+        editable: true,
+        version: 1
+      }
+
+      try {
+        console.log(`[setupGrafana] Verificando datasource Tempo existente: ${tempoDatasourceUid} na org ${org.id}`)
+        const existingTempo = await axios.get(`${grafanaUrl}/api/datasources/uid/${tempoDatasourceUid}`, {
+          auth,
+          headers: { 'X-Grafana-Org-Id': org.id },
+          timeout: 3000
+        })
+        console.log(`[setupGrafana] Datasource Tempo existente encontrado: ${existingTempo.data?.id || 'N/A'}`)
+        try {
+          await axios.put(
+            `${grafanaUrl}/api/datasources/${existingTempo.data.id}`,
+            tempoDatasourceConfig,
+            {
+              auth,
+              headers: { 'X-Grafana-Org-Id': org.id },
+              timeout: 3000
+            }
+          )
+          console.log(`[setupGrafana] ✅ Datasource Tempo atualizado: ${tempoDatasourceUid}`)
+        } catch (updateTempoErr) {
+          console.error(`[setupGrafana] ⚠️  Erro ao atualizar datasource Tempo: ${updateTempoErr.response?.data?.message || updateTempoErr.message}`)
+        }
+      } catch (tempoError) {
+        console.log(`[setupGrafana] Erro ao verificar datasource Tempo: status=${tempoError.response?.status || 'N/A'}, message=${tempoError.response?.data?.message || tempoError.message}`)
+        if (tempoError.response?.status === 404) {
+          try {
+            const tempoCreate = await axios.post(
+              `${grafanaUrl}/api/datasources`,
+              tempoDatasourceConfig,
+              {
+                auth,
+                headers: { 'X-Grafana-Org-Id': org.id },
+                timeout: 3000
+              }
+            )
+            console.log(`[setupGrafana] ✅ Datasource Tempo criado: ${tempoDatasourceUid} (ID: ${tempoCreate.data?.datasource?.id || 'N/A'})`)
+          } catch (createTempoError) {
+            console.error(`[setupGrafana] ⚠️  Erro ao criar datasource Tempo via API: ${createTempoError.response?.data?.message || createTempoError.message}`)
+            console.log(`[setupGrafana] 💡 Datasource Tempo será criado manualmente ou na próxima tentativa`)
+          }
+        }
+      }
+    } catch (tempoGeneralError) {
+      console.error(`[setupGrafana] ⚠️  Erro geral ao configurar datasource Tempo: ${tempoGeneralError.message}`)
+      console.log(`[setupGrafana] 💡 Continuando sem datasource Tempo - não é crítico para funcionamento básico`)
+    }
+
     console.log(`[setupGrafana] 📈 Criando dashboard para ${appName}...`)
     
     const appNameLower = appName.toLowerCase()
@@ -865,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') ||
@@ -874,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
@@ -1104,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