azify-logger 1.0.24 → 1.0.26

package/server.js

@@ -4,6 +4,7 @@ const axios = require('axios')
 const express = require('express')
 const cors = require('cors')
 const os = require('os')
+const fs = require('fs')
 let trace, context, propagation, W3CTraceContextPropagator
 try {
   const otelApi = require('@opentelemetry/api')
@@ -27,6 +28,17 @@ app.use(express.json({ limit: '10mb' }))
 app.use(express.urlencoded({ extended: true, limit: '10mb' }))
 app.use(cors())
 
+const authEnabled = process.env.AZURE_AD_AUTH_ENABLED === 'true'
+let ensureAuthenticated = (req, res, next) => next()
+let ensureAdmin = (req, res, next) => res.status(403).send('Forbidden')
+if (authEnabled) {
+  const { setupAuth, setupAuthRoutes, ensureAuthenticated: _ensureAuth, ensureAdmin: _ensureAdmin } = require('./auth')
+  setupAuth(app)
+  setupAuthRoutes(app)
+  ensureAuthenticated = _ensureAuth
+  ensureAdmin = _ensureAdmin
+}
+
 const IS_LOCAL = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'dev' || !process.env.NODE_ENV
 
 function isPrivateOrLocalhost(ip) {
@@ -83,12 +95,6 @@ const propagator = new W3CTraceContextPropagator()
 
 const traceContextMap = new Map()
 
-/**
- * Creates an index template for dynamic log indices
- * This allows OpenSearch to auto-create indices like logs-azipay, logs-assemble, etc.
- * @returns {Promise<void>}
- * @private
- */
 async function ensureIndexTemplate() {
   const templateName = 'logs-template'
   const osUrl = process.env.OPENSEARCH_URL || 'http://localhost:9200'
@@ -97,61 +103,659 @@ async function ensureIndexTemplate() {
     await axios.put(`${osUrl}/_index_template/${templateName}`, {
       index_patterns: ['logs-*'],
       template: {
-        settings: {
-          number_of_shards: 1,
+          settings: {
+            number_of_shards: 1,
           number_of_replicas: 0,
           'index.refresh_interval': '5s'
-        },
-        mappings: {
-          properties: {
+          },
+          mappings: {
+            properties: {
             '@timestamp': { type: 'date' },
-            level: { type: 'keyword' },
-            message: { type: 'text' },
-            service: {
-              properties: {
-                name: { type: 'keyword' },
-                version: { type: 'keyword' }
+              level: { type: 'keyword' },
+              message: { type: 'text' },
+              service: {
+                properties: {
+                  name: { type: 'keyword' },
+                  version: { type: 'keyword' }
+                }
+              },
+            appName: { 
+              type: 'keyword',
+              fields: {
+                keyword: { type: 'keyword' }
               }
             },
-            appName: { type: 'keyword' },
-            traceId: { type: 'keyword' },
-            spanId: { type: 'keyword' },
-            parentSpanId: { type: 'keyword' },
-            userId: { type: 'keyword' },
-            requestId: { type: 'keyword' },
-            method: { type: 'keyword' },
-            url: { type: 'keyword' },
-            statusCode: { type: 'integer' },
-            responseTime: { type: 'float' },
-            ip: { type: 'ip' },
-            userAgent: { type: 'text' },
-            environment: { type: 'keyword' },
-            hostname: { type: 'keyword' },
-            responseBody: { type: 'text' },
-            error: {
-              properties: {
-                message: { type: 'text' },
-                stack: { type: 'text' },
-                name: { type: 'keyword' }
+              traceId: { type: 'keyword' },
+              spanId: { type: 'keyword' },
+              parentSpanId: { type: 'keyword' },
+              userId: { type: 'keyword' },
+              requestId: { type: 'keyword' },
+              method: { type: 'keyword' },
+              url: { type: 'keyword' },
+              statusCode: { type: 'integer' },
+              responseTime: { type: 'float' },
+              ip: { type: 'ip' },
+              userAgent: { type: 'text' },
+              environment: { type: 'keyword' },
+              hostname: { type: 'keyword' },
+              responseBody: { type: 'text' },
+              error: {
+                properties: {
+                  message: { type: 'text' },
+                  stack: { type: 'text' },
+                  name: { type: 'keyword' }
+                }
               }
             }
           }
-        }
       },
       priority: 500
     })
-    console.log(`✅ Index template ${templateName} criado/atualizado no OpenSearch`)
-    console.log(`   Índices serão criados automaticamente no formato: logs-{service-name}`)
   } catch (error) {
-    console.error('❌ Erro ao criar index template:', error.message)
-    if (error.response) {
-      console.error('   Detalhes:', error.response.data)
-    }
   }
 }
 
 ensureIndexTemplate()
 
+function escapeForSQLite(str) {
+  if (!str) return "''"
+  return str.replace(/'/g, "''").replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/\r/g, '\\r')
+}
+
+async function createOrgViaSQLite(appName) {
+  const dbPath = '/var/lib/grafana/grafana.db'
+
+  try {
+    console.log(`[createOrgViaSQLite] Verificando database em ${dbPath}...`)
+    if (!fs.existsSync(dbPath)) {
+      console.error(`[createOrgViaSQLite] ❌ Database não encontrado em ${dbPath}`)
+      throw new Error(`Database não encontrado em ${dbPath}`)
+    }
+    
+    const { execSync } = require('child_process')
+    
+    console.log(`[createOrgViaSQLite] Verificando se Organization '${appName}' já existe...`)
+    const checkCmd = `sqlite3 ${dbPath} "SELECT id FROM org WHERE name='${appName}';" 2>/dev/null || echo ""`
+    const existingId = execSync(checkCmd, { encoding: 'utf8' }).trim()
+    
+    if (existingId && existingId !== '') {
+      console.log(`[createOrgViaSQLite] ✅ Organization '${appName}' já existe (ID: ${existingId})`)
+      return { id: parseInt(existingId), name: appName }
+    }
+    
+    console.log(`[createOrgViaSQLite] Criando Organization '${appName}'...`)
+    const createCmd = `sqlite3 ${dbPath} "INSERT INTO org (name, version, created, updated) VALUES ('${appName}', 1, datetime('now'), datetime('now')); SELECT id FROM org WHERE name='${appName}';" 2>/dev/null`
+    const newId = execSync(createCmd, { encoding: 'utf8' }).trim()
+    
+    if (newId && newId !== '') {
+      console.log(`[createOrgViaSQLite] ✅ Organization '${appName}' criada com sucesso (ID: ${newId})`)
+      return { id: parseInt(newId), name: appName }
+    }
+    
+    console.error(`[createOrgViaSQLite] ❌ Não foi possível obter ID da Organization criada`)
+    return null
+  } catch (error) {
+    console.error(`[createOrgViaSQLite] ❌ Erro: ${error.message}`)
+    throw new Error(`Erro ao criar Organization via SQLite: ${error.message}`)
+  }
+}
+
+async function setupGrafanaForApp(appName) {
+  const grafanaUrl = process.env.GRAFANA_URL || 'http://azify-grafana:3000'
+  const grafanaAdminUser = process.env.GRAFANA_ADMIN_USER || 'admin'
+  const grafanaAdminPassword = process.env.GRAFANA_ADMIN_PASSWORD || process.env.GF_SECURITY_ADMIN_PASSWORD || 'admin'
+  const opensearchUrl = process.env.OPENSEARCH_URL || 'http://azify-opensearch:9200'
+
+  if (!setupGrafanaForApp._cache) {
+    setupGrafanaForApp._cache = new Set()
+  }
+  
+  if (setupGrafanaForApp._cache.has(appName)) {
+    return
+  }
+  
+  setupGrafanaForApp._cache.add(appName)
+  
+  console.log(`[setupGrafana] Processando app: ${appName}`)
+
+  try {
+    const auth = {
+      username: grafanaAdminUser,
+      password: grafanaAdminPassword
+    }
+    
+    console.log(`[setupGrafana] Usando autenticação: user=${grafanaAdminUser}, password=${grafanaAdminPassword ? '***' : 'VAZIO'}`)
+
+    let org
+    
+    try {
+      const orgResponse = await axios.get(`${grafanaUrl}/api/orgs/name/${encodeURIComponent(appName)}`, { 
+        auth,
+        timeout: 3000
+      })
+      org = orgResponse.data
+      console.log(`[setupGrafana] ✅ Organization encontrada via API: ${org.name} (ID: ${org.id})`)
+    } catch (apiError) {
+      if (apiError.response?.status === 404) {
+        try {
+          const createResponse = await axios.post(
+            `${grafanaUrl}/api/orgs`,
+            { name: appName },
+            { auth, timeout: 3000 }
+          )
+          org = { id: createResponse.data.orgId, name: appName }
+          console.log(`[setupGrafana] ✅ Organization criada via API: ${org.name} (ID: ${org.id})`)
+        } catch (createError) {
+          console.log(`[setupGrafana] ⚠️  Erro ao criar Organization via API: ${createError.response?.status || 'N/A'} - ${createError.response?.data?.message || createError.message}`)
+          try {
+            console.log(`[setupGrafana] 🔄 Tentando criar Organization via SQLite...`)
+            org = await createOrgViaSQLite(appName)
+            if (!org) {
+              console.error(`[setupGrafana] ❌ Não foi possível criar Organization via SQLite para ${appName}`)
+              return
+            }
+          } catch (sqliteError) {
+            console.error(`[setupGrafana] ❌ Erro ao criar Organization via SQLite: ${sqliteError.message}`)
+            return
+          }
+        }
+      } else {
+        console.log(`[setupGrafana] ⚠️  Erro ao buscar Organization via API: ${apiError.response?.status || 'N/A'} - ${apiError.response?.data?.message || apiError.message}`)
+        try {
+          console.log(`[setupGrafana] 🔄 Tentando criar Organization via SQLite...`)
+          org = await createOrgViaSQLite(appName)
+          if (!org) {
+            console.error(`[setupGrafana] ❌ Não foi possível criar Organization via SQLite para ${appName}`)
+            return
+          }
+        } catch (sqliteError) {
+          console.error(`[setupGrafana] ❌ Erro ao criar Organization via SQLite: ${sqliteError.message}`)
+          return
+        }
+      }
+    }
+
+    if (!org) {
+      console.error(`[setupGrafana] ❌ Organization não encontrada/criada para ${appName}`)
+      return
+    }
+    
+    console.log(`[setupGrafana] ✅ Organization encontrada/criada: ${org.name} (ID: ${org.id})`)
+
+    const adminEmails = process.env.ADMIN_EMAILS ? process.env.ADMIN_EMAILS.split(',') : []
+    if (adminEmails.length > 0) {
+      for (const email of adminEmails) {
+        const trimmedEmail = email.trim()
+        if (!trimmedEmail) continue
+        
+        try {
+          const userResponse = await axios.get(`${grafanaUrl}/api/users/lookup?loginOrEmail=${encodeURIComponent(trimmedEmail)}`, {
+            auth,
+            timeout: 3000
+          })
+          
+          if (userResponse.data && userResponse.data.id) {
+            const userId = userResponse.data.id
+            
+            try {
+              await axios.post(
+                `${grafanaUrl}/api/orgs/${org.id}/users`,
+                {
+                  loginOrEmail: trimmedEmail,
+                  role: 'Admin'
+                },
+                {
+                  auth,
+                  headers: { 'X-Grafana-Org-Id': org.id },
+                  timeout: 3000
+                }
+              )
+            } catch (addError) {
+              if (addError.response?.status === 409 || addError.response?.status === 412) {
+                try {
+                  await axios.patch(
+                    `${grafanaUrl}/api/orgs/${org.id}/users/${userId}`,
+                    { role: 'Admin' },
+                    {
+                      auth,
+                      headers: { 'X-Grafana-Org-Id': org.id },
+                      timeout: 3000
+                    }
+                  )
+                } catch (updateError) {
+                }
+              } else {
+              }
+            }
+          }
+        } catch (userError) {
+          const dbUserId = await new Promise((resolve) => {
+            const { execSync } = require('child_process')
+            try {
+              const result = execSync(`sqlite3 /var/lib/grafana/grafana.db "SELECT id FROM user WHERE email='${trimmedEmail}';"`, { encoding: 'utf8' }).trim()
+              resolve(result || null)
+            } catch {
+              resolve(null)
+            }
+          })
+          
+          if (dbUserId) {
+            const { execSync } = require('child_process')
+            try {
+              execSync(`sqlite3 /var/lib/grafana/grafana.db "INSERT OR IGNORE INTO org_user (org_id, user_id, role, created, updated) VALUES (${org.id}, ${dbUserId}, 'Admin', datetime('now'), datetime('now')); UPDATE org_user SET role='Admin' WHERE org_id=${org.id} AND user_id=${dbUserId};"`, { encoding: 'utf8' })
+            } catch {
+            }
+          }
+        }
+      }
+    }
+
+    console.log(`[setupGrafana] 📊 Criando datasource para ${appName}...`)
+    
+    const datasourceUid = `opensearch-${appName.toLowerCase()}`
+    const datasourceConfig = {
+      name: `OpenSearch-${appName}`,
+      type: 'grafana-opensearch-datasource',
+      access: 'proxy',
+      url: opensearchUrl,
+      uid: datasourceUid,
+      isDefault: true,
+      jsonData: {
+        index: `logs-${appName}`,
+        database: `logs-${appName}`,
+        timeField: '@timestamp',
+        esVersion: '2.11.1',
+        version: '2.11.1',
+        logMessageField: 'message',
+        logLevelField: 'level',
+        maxConcurrentShardRequests: 5,
+        includeFrozen: false,
+        xpack: false,
+        flavor: 'opensearch'
+      },
+      editable: true,
+      version: 1
+    }
+
+    try {
+      console.log(`[setupGrafana] Verificando datasource existente: ${datasourceUid} na org ${org.id}`)
+      const existingResponse = await axios.get(`${grafanaUrl}/api/datasources/uid/${datasourceUid}`, {
+        auth,
+        headers: { 'X-Grafana-Org-Id': org.id }
+      })
+      console.log(`[setupGrafana] Datasource existente encontrado: ${existingResponse.data?.id || 'N/A'}`)
+      
+      try {
+        await axios.put(
+          `${grafanaUrl}/api/datasources/${existingResponse.data.id}`,
+          datasourceConfig,
+          {
+            auth,
+            headers: { 'X-Grafana-Org-Id': org.id }
+          }
+        )
+        console.log(`[setupGrafana] ✅ Datasource atualizado: ${datasourceUid}`)
+      } catch (updateError) {
+        console.error(`[setupGrafana] ❌ Erro ao atualizar datasource: ${updateError.response?.data?.message || updateError.message}`)
+      }
+    } catch (error) {
+      console.log(`[setupGrafana] Erro ao verificar datasource: status=${error.response?.status || 'N/A'}, message=${error.response?.data?.message || error.message}`)
+      if (error.response?.status === 404) {
+        try {
+          const createResponse = await axios.post(
+            `${grafanaUrl}/api/datasources`,
+            datasourceConfig,
+            {
+              auth,
+              headers: { 'X-Grafana-Org-Id': org.id }
+            }
+          )
+          console.log(`[setupGrafana] ✅ Datasource criado: ${datasourceUid} (ID: ${createResponse.data?.datasource?.id || 'N/A'})`)
+        } catch (createError) {
+          console.error(`[setupGrafana] ❌ Erro ao criar datasource via API: ${createError.response?.data?.message || createError.message}`)
+          if (createError.response?.status === 401) {
+            console.log(`[setupGrafana] 🔄 Tentando criar datasource via SQLite...`)
+            try {
+              const { execSync } = require('child_process')
+              const dsJson = JSON.stringify(datasourceConfig.jsonData)
+              const dsName = escapeForSQLite(datasourceConfig.name)
+              const opensearchUrlEscaped = escapeForSQLite(opensearchUrl)
+              const dsUidEscaped = escapeForSQLite(datasourceUid)
+              const jsonEscaped = dsJson.replace(/'/g, "''")
+              const tempFile = `/tmp/ds_${org.id}_${Date.now()}.sql`
+              const sql = `INSERT INTO data_source (org_id, version, type, name, access, url, is_default, json_data, uid, created, updated, basic_auth, with_credentials) VALUES (${org.id}, 1, 'grafana-opensearch-datasource', '${dsName}', 'proxy', '${opensearchUrlEscaped}', ${datasourceConfig.isDefault ? 1 : 0}, '${jsonEscaped}', '${dsUidEscaped}', datetime('now'), datetime('now'), 0, 0); SELECT last_insert_rowid();`
+              fs.writeFileSync(tempFile, sql)
+              const cmd = `sqlite3 /var/lib/grafana/grafana.db < ${tempFile}`
+              const dsId = execSync(cmd, { encoding: 'utf8' }).trim()
+              fs.unlinkSync(tempFile)
+              console.log(`[setupGrafana] ✅ Datasource criado via SQLite: ${datasourceUid} (ID: ${dsId})`)
+            } catch (sqliteError) {
+              console.error(`[setupGrafana] ❌ Erro ao criar datasource via SQLite: ${sqliteError.message}`)
+              try { 
+                const tempFiles = fs.readdirSync('/tmp').filter(f => f.startsWith('ds_'))
+                tempFiles.forEach(f => { try { fs.unlinkSync(`/tmp/${f}`) } catch {} })
+              } catch {}
+            }
+          }
+        }
+      } else {
+        console.error(`[setupGrafana] ❌ Erro ao verificar datasource: ${error.response?.data?.message || error.message} (status: ${error.response?.status || 'N/A'})`)
+        if (error.response?.status === 401) {
+          console.log(`[setupGrafana] 🔄 Tentando criar datasource via SQLite (erro 401 na verificação)...`)
+          try {
+            const { execSync } = require('child_process')
+            const dsJson = JSON.stringify(datasourceConfig.jsonData)
+            const dsName = escapeForSQLite(datasourceConfig.name)
+            const opensearchUrlEscaped = escapeForSQLite(opensearchUrl)
+            const dsUidEscaped = escapeForSQLite(datasourceUid)
+            const jsonEscaped = dsJson.replace(/'/g, "''")
+            const tempFile = `/tmp/ds2_${org.id}_${Date.now()}.sql`
+            const sql = `INSERT INTO data_source (org_id, version, type, name, access, url, is_default, json_data, uid, created, updated, basic_auth, with_credentials) VALUES (${org.id}, 1, 'grafana-opensearch-datasource', '${dsName}', 'proxy', '${opensearchUrlEscaped}', ${datasourceConfig.isDefault ? 1 : 0}, '${jsonEscaped}', '${dsUidEscaped}', datetime('now'), datetime('now'), 0, 0); SELECT last_insert_rowid();`
+            fs.writeFileSync(tempFile, sql)
+            const cmd = `sqlite3 /var/lib/grafana/grafana.db < ${tempFile}`
+            const dsId = execSync(cmd, { encoding: 'utf8' }).trim()
+            fs.unlinkSync(tempFile)
+            console.log(`[setupGrafana] ✅ Datasource criado via SQLite: ${datasourceUid} (ID: ${dsId})`)
+          } catch (sqliteError) {
+            console.error(`[setupGrafana] ❌ Erro ao criar datasource via SQLite: ${sqliteError.message}`)
+            try { 
+              const tempFiles = fs.readdirSync('/tmp').filter(f => f.startsWith('ds'))
+              tempFiles.forEach(f => { try { fs.unlinkSync(`/tmp/${f}`) } catch {} })
+            } catch {}
+          }
+        }
+      }
+    }
+
+    console.log(`[setupGrafana] 📈 Criando dashboard para ${appName}...`)
+    
+    const appNameLower = appName.toLowerCase()
+    const indexFilter = `_index:logs-${appNameLower}`
+    
+    const dashboardConfig = {
+        dashboard: {
+          title: `Application Health - ${appName}`,
+          tags: ['health', 'metrics', appNameLower],
+          timezone: 'browser',
+          schemaVersion: 38,
+          version: 0,
+          refresh: '30s',
+          time: { from: 'now-24h', to: 'now' },
+          editable: false,
+          panels: [
+            {
+              id: 1,
+              gridPos: { h: 8, w: 6, x: 0, y: 0 },
+              type: 'stat',
+              title: 'Total de Requisições',
+              datasource: { uid: datasourceUid, type: 'grafana-opensearch-datasource' },
+              targets: [{
+                refId: 'A',
+                query: `message:"[REQUEST]" AND NOT message:"[RESPONSE]" AND ${indexFilter}`,
+                bucketAggs: [{
+                  id: '2',
+                  type: 'date_histogram',
+                  field: '@timestamp',
+                  settings: { interval: 'auto', min_doc_count: 0 }
+                }],
+                metrics: [{ id: '1', type: 'count' }]
+              }],
+              fieldConfig: {
+                defaults: {
+                  unit: 'short',
+                  color: { mode: 'thresholds' },
+                  custom: { 
+                    reduceOptions: { 
+                      values: false, 
+                      calcs: ['sum'] 
+                    } 
+                  }
+                }
+              },
+              options: {
+                reduceOptions: { values: false, calcs: ['sum'], fields: '' },
+                orientation: 'auto',
+                textMode: 'auto',
+                colorMode: 'value',
+                graphMode: 'none',
+                justifyMode: 'auto'
+              }
+            },
+            {
+              id: 2,
+              gridPos: { h: 8, w: 6, x: 6, y: 0 },
+              type: 'stat',
+              title: 'Taxa de Sucesso (2xx)',
+              datasource: { uid: datasourceUid, type: 'grafana-opensearch-datasource' },
+              targets: [{
+                refId: 'A',
+                query: `message:"[RESPONSE]" AND statusCode:[200 TO 299] AND ${indexFilter}`,
+                bucketAggs: [{
+                  id: '2',
+                  type: 'date_histogram',
+                  field: '@timestamp',
+                  settings: { interval: 'auto', min_doc_count: 0 }
+                }],
+                metrics: [{ id: '1', type: 'count' }]
+              }],
+              fieldConfig: {
+                defaults: {
+                  unit: 'short',
+                  color: { mode: 'thresholds', thresholds: { mode: 'absolute', steps: [{ value: null, color: 'green' }] } },
+                  custom: { reduceOptions: { values: false, calcs: ['sum'] } }
+                }
+              },
+              options: {
+                reduceOptions: { values: false, calcs: ['sum'], fields: '' },
+                orientation: 'auto',
+                textMode: 'auto',
+                colorMode: 'value',
+                graphMode: 'none',
+                justifyMode: 'auto'
+              }
+            },
+            {
+              id: 3,
+              gridPos: { h: 8, w: 6, x: 12, y: 0 },
+              type: 'stat',
+              title: 'Erros 4xx',
+              datasource: { uid: datasourceUid, type: 'grafana-opensearch-datasource' },
+              targets: [{
+                refId: 'A',
+                query: `message:"[RESPONSE]" AND statusCode:[400 TO 499] AND ${indexFilter}`,
+                bucketAggs: [{
+                  id: '2',
+                  type: 'date_histogram',
+                  field: '@timestamp',
+                  settings: { interval: 'auto', min_doc_count: 0 }
+                }],
+                metrics: [{ id: '1', type: 'count' }]
+              }],
+              fieldConfig: {
+                defaults: {
+                  unit: 'short',
+                  color: { mode: 'thresholds', thresholds: { mode: 'absolute', steps: [{ value: null, color: 'yellow' }] } },
+                  custom: { reduceOptions: { values: false, calcs: ['sum'] } }
+                }
+              },
+              options: {
+                reduceOptions: { values: false, calcs: ['sum'], fields: '' },
+                orientation: 'auto',
+                textMode: 'auto',
+                colorMode: 'value',
+                graphMode: 'none',
+                justifyMode: 'auto'
+              }
+            },
+            {
+              id: 4,
+              gridPos: { h: 8, w: 6, x: 18, y: 0 },
+              type: 'stat',
+              title: 'Erros 5xx',
+              datasource: { uid: datasourceUid, type: 'grafana-opensearch-datasource' },
+              targets: [{
+                refId: 'A',
+                query: `message:"[RESPONSE]" AND statusCode:[500 TO 599] AND ${indexFilter}`,
+                bucketAggs: [{
+                  id: '2',
+                  type: 'date_histogram',
+                  field: '@timestamp',
+                  settings: { interval: 'auto', min_doc_count: 0 }
+                }],
+                metrics: [{ id: '1', type: 'count' }]
+              }],
+              fieldConfig: {
+                defaults: {
+                  unit: 'short',
+                  color: { mode: 'thresholds', thresholds: { mode: 'absolute', steps: [{ value: null, color: 'red' }] } },
+                  custom: { reduceOptions: { values: false, calcs: ['sum'] } }
+                }
+              },
+              options: {
+                reduceOptions: { values: false, calcs: ['sum'], fields: '' },
+                orientation: 'auto',
+                textMode: 'auto',
+                colorMode: 'value',
+                graphMode: 'none',
+                justifyMode: 'auto'
+              }
+            },
+            {
+              id: 5,
+              gridPos: { h: 8, w: 12, x: 0, y: 8 },
+              type: 'stat',
+              title: 'Tempo Médio de Resposta (ms)',
+              datasource: { uid: datasourceUid, type: 'grafana-opensearch-datasource' },
+              targets: [{
+                refId: 'A',
+                query: `message:"[RESPONSE]" AND ${indexFilter}`,
+                bucketAggs: [{
+                  id: '2',
+                  type: 'date_histogram',
+                  field: '@timestamp',
+                  settings: { interval: 'auto', min_doc_count: 0 }
+                }],
+                metrics: [{ id: '1', type: 'avg', field: 'responseTime' }]
+              }],
+              fieldConfig: {
+                defaults: {
+                  unit: 'ms',
+                  color: { mode: 'thresholds' },
+                  custom: { reduceOptions: { values: false, calcs: ['mean'] } }
+                }
+              },
+              options: {
+                reduceOptions: { values: false, calcs: ['mean'], fields: '' },
+                orientation: 'auto',
+                textMode: 'auto',
+                colorMode: 'value',
+                graphMode: 'none',
+                justifyMode: 'auto'
+              }
+            },
+            {
+              id: 6,
+              gridPos: { h: 8, w: 12, x: 12, y: 8 },
+              type: 'timeseries',
+              title: 'Requisições por Minuto',
+              datasource: { uid: datasourceUid, type: 'grafana-opensearch-datasource' },
+              targets: [{
+                refId: 'A',
+                query: `message:"[REQUEST]" AND NOT message:"[RESPONSE]" AND ${indexFilter}`,
+                bucketAggs: [{
+                  id: '2',
+                  type: 'date_histogram',
+                  field: '@timestamp',
+                  settings: { interval: '1m', min_doc_count: 0 }
+                }],
+                metrics: [{ id: '1', type: 'count' }]
+              }]
+            }
+          ]
+        },
+        overwrite: true
+      }
+
+    try {
+      const searchResponse = await axios.get(`${grafanaUrl}/api/search?query=Application Health - ${appName}&type=dash-db`, {
+        auth,
+        headers: { 'X-Grafana-Org-Id': org.id }
+      })
+      
+      if (searchResponse.data && searchResponse.data.length > 0) {
+        const existingDashboard = searchResponse.data[0]
+        const dashboardDetail = await axios.get(`${grafanaUrl}/api/dashboards/uid/${existingDashboard.uid}`, {
+          auth,
+          headers: { 'X-Grafana-Org-Id': org.id }
+        })
+        
+        dashboardConfig.dashboard.id = dashboardDetail.data.dashboard.id
+        dashboardConfig.dashboard.uid = dashboardDetail.data.dashboard.uid
+        dashboardConfig.dashboard.version = dashboardDetail.data.dashboard.version
+      }
+    } catch (searchError) {
+    }
+
+    try {
+      const dashboardResponse = await axios.post(
+        `${grafanaUrl}/api/dashboards/db`,
+        dashboardConfig,
+        {
+          auth,
+          headers: { 'X-Grafana-Org-Id': org.id, 'Content-Type': 'application/json' }
+        }
+      )
+      console.log(`[setupGrafana] ✅ Dashboard criado: ${dashboardResponse.data?.dashboard?.title || 'N/A'} (UID: ${dashboardResponse.data?.dashboard?.uid || 'N/A'})`)
+    } catch (error) {
+      console.error(`[setupGrafana] ❌ Erro ao criar dashboard via API: ${error.response?.data?.message || error.message}`)
+      if (error.response?.status === 401 && typeof dashboardConfig !== 'undefined' && dashboardConfig && dashboardConfig.dashboard) {
+        console.log(`[setupGrafana] 🔄 Tentando criar dashboard via SQLite...`)
+        try {
+          const { execSync } = require('child_process')
+          const dashboardUid = `dashboard-${appName.toLowerCase()}`
+          const dashboardTitle = `Application Health - ${appName}`
+          const dashboardJson = JSON.stringify(dashboardConfig.dashboard)
+          const escapedJson = dashboardJson.replace(/'/g, "''")
+          const escapedTitle = escapeForSQLite(dashboardTitle)
+          const slug = dashboardTitle.toLowerCase().replace(/[^a-z0-9-]/g, '-')
+          const slugEscaped = escapeForSQLite(slug)
+          const uidEscaped = escapeForSQLite(dashboardUid)
+          const tempFile = `/tmp/dash_${org.id}_${Date.now()}.sql`
+          const sql = `INSERT INTO dashboard (org_id, version, slug, title, data, created, updated, uid, is_folder, folder_id) VALUES (${org.id}, 0, '${slugEscaped}', '${escapedTitle}', '${escapedJson}', datetime('now'), datetime('now'), '${uidEscaped}', 0, 0); SELECT last_insert_rowid();`
+          fs.writeFileSync(tempFile, sql)
+          const cmd = `sqlite3 /var/lib/grafana/grafana.db < ${tempFile}`
+          const dashboardId = execSync(cmd, { encoding: 'utf8' }).trim()
+          fs.unlinkSync(tempFile)
+          console.log(`[setupGrafana] ✅ Dashboard criado via SQLite: ${dashboardTitle} (ID: ${dashboardId})`)
+        } catch (sqliteError) {
+          console.error(`[setupGrafana] ❌ Erro ao criar dashboard via SQLite: ${sqliteError.message}`)
+          try { 
+            const tempFiles = fs.readdirSync('/tmp').filter(f => f.startsWith('dash_'))
+            tempFiles.forEach(f => { try { fs.unlinkSync(`/tmp/${f}`) } catch {} })
+          } catch {}
+        }
+      } else {
+        console.error(`[setupGrafana] ⚠️  Não foi possível criar dashboard via SQLite: dashboardConfig não disponível`)
+      }
+    }
+
+    console.log(`[setupGrafana] ✅ Setup completo para ${appName} (Organization, Datasource e Dashboard)`)
+    
+    setTimeout(() => {
+      setupGrafanaForApp._cache.delete(appName)
+    }, 3600000)
+
+  } catch (error) {
+    setupGrafanaForApp._cache.delete(appName)
+    const errorMsg = error.response?.data?.message || error.message || 'Erro desconhecido'
+    console.error(`[setupGrafana] ❌ Erro no setup de ${appName}: ${errorMsg}`)
+    if (error.stack) {
+      console.error(`[setupGrafana] Stack: ${error.stack.substring(0, 300)}`)
+    }
+    throw new Error(errorMsg)
+  }
+}
+
 function generateTraceId() {
   return Math.random().toString(36).substring(2, 15) +
          Math.random().toString(36).substring(2, 15)
@@ -184,28 +788,78 @@ function getOrCreateTraceContext(requestId) {
 app.get('/health', (req, res) => {
   res.json({ 
     status: 'ok', 
-    service: 'azify-logger'
+    service: 'azify-logger',
+    authEnabled
   })
 })
 
-app.get('/', (req, res) => {
+app.get('/', ensureAuthenticated, (req, res) => {
   res.json({
     service: 'azify-logger',
     version: '1.0.0',
     endpoints: {
       health: '/health',
-      testLog: '/test-log'
+      testLog: '/test-log',
     }
   })
 })
 
-app.post('/log', async (req, res) => {
+
+function decodeHtmlEntities(str) {
+  if (!str || typeof str !== 'string') return str
+  let decoded = str
+  let prev = ''
+  let iterations = 0
+  const maxIterations = 10
+  
+  const namedEntities = {
+    '&quot;': '"',
+    '&apos;': "'",
+    '&lt;': '<',
+    '&gt;': '>',
+    '&amp;': '&',
+    '&nbsp;': ' '
+  }
+  
+  while (decoded !== prev && iterations < maxIterations) {
+    prev = decoded
+    Object.keys(namedEntities).forEach(entity => {
+      if (entity !== '&amp;') {
+        decoded = decoded.replace(new RegExp(entity.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'), namedEntities[entity])
+      }
+    })
+    decoded = decoded.replace(/&amp;/gi, '&')
+    decoded = decoded.replace(/&#x([0-9a-fA-F]+);/gi, (match, hex) => {
+      try {
+        return String.fromCharCode(parseInt(hex, 16))
+      } catch (e) {
+        return match
+      }
+    })
+    decoded = decoded.replace(/&#([0-9]+);/g, (match, dec) => {
+      try {
+        return String.fromCharCode(parseInt(dec, 10))
+      } catch (e) {
+        return match
+      }
+    })
+    iterations++
+  }
+  
+  return decoded
+}
+
+async function handleLog(req, res) {
   let { level, message, meta } = req.body
   
   if (!level || !message) {
     return res.status(400).json({ success: false, message: 'Level and message are required.' })
   }
 
+  if (typeof message === 'string') {
+    message = decodeHtmlEntities(message)
+  }
+
   const shouldFilterLog = (
     message.includes('prisma:query') ||
     message.includes('prisma:info') ||
@@ -288,43 +942,84 @@ app.post('/log', async (req, res) => {
   if (meta) {
     Object.keys(meta).forEach(key => {
       if (!['timestamp', 'service', 'environment', 'hostname', 'traceId', 'spanId', 'parentSpanId'].includes(key)) {
-        logEntry[key] = meta[key]
+        let value = meta[key]
+        
+        if (typeof value === 'string') {
+          if (key === 'url' || key === 'path' || key === 'baseUrl' || key === 'message') {
+            value = decodeHtmlEntities(value)
+          } else if (value.includes('&#') || value.includes('&amp;')) {
+            value = decodeHtmlEntities(value)
+          }
+        }
+        
+        if (key === 'responseBody') {
+          if (typeof value === 'object' && value !== null) {
+            try {
+              value = JSON.stringify(value)
+            } catch (e) {
+              return
+            }
+          } else if (typeof value === 'string' && value.length > 10000) {
+            value = value.substring(0, 10000) + '... [truncated]'
+          }
+          if (typeof value === 'object' && value !== null) {
+            return
+          }
+        }
+        
+        logEntry[key] = value
       }
     })
   }
 
+  logEntry.message = message
+
   try {
     const osUrl = process.env.OPENSEARCH_URL || 'http://localhost:9200'
-    const serviceName = (logEntry.service.name || 'unknown').toLowerCase().replace(/[^a-z0-9-]/g, '-')
+    const appName = logEntry.appName || logEntry.service?.name || 'unknown'
+    const serviceName = appName.toLowerCase().replace(/[^a-z0-9-]/g, '-')
     const indexName = `logs-${serviceName}`
     
     await axios.post(`${osUrl}/${indexName}/_doc`, logEntry, {
       headers: { 'Content-Type': 'application/json' }
     })
     
-    console.log(`✅ [${level.toUpperCase()}] ${message} | traceId: ${traceContext.traceId.substring(0, 8)}... | service: ${logEntry.service.name} | index: ${indexName}`)
+    console.log(`[setupGrafana] serviceName: ${serviceName}, appName: ${appName}`)
+    
+    if (serviceName !== 'unknown' && serviceName !== 'unknown-service') {
+      console.log(`[setupGrafana] Iniciando setup para app: ${serviceName}`)
+      setupGrafanaForApp(serviceName).then(() => {
+        console.log(`[setupGrafana] ✅ Setup concluído para ${serviceName}`)
+      }).catch((err) => {
+        const errorMsg = err?.response?.data?.message || err?.message || 'Erro desconhecido'
+        const status = err?.response?.status || 'N/A'
+        console.error(`[setupGrafana] ❌ Erro ao configurar Grafana para ${serviceName}: ${errorMsg} (status: ${status})`)
+        if (err?.stack) {
+          console.error(`[setupGrafana] Stack: ${err.stack.substring(0, 200)}`)
+        }
+      })
+    } else {
+      console.log(`[setupGrafana] ⚠️  Pulando setup para serviceName inválido: ${serviceName}`)
+    }
+    
     res.json({ success: true, message: 'Log enviado com sucesso', index: indexName })
   } catch (error) {
-    console.error('❌ Erro ao enviar log para OpenSearch:', error.message)
-    if (error.response) {
-      console.error('   Detalhes:', error.response.data)
-    }
     res.status(500).json({ success: false, message: 'Erro ao enviar log para OpenSearch' })
   }
-})
+}
+
+app.post('/log', (req, res) => handleLog(req, res))
+app.post('/send', (req, res) => handleLog(req, res))
 
 const port = process.env.PORT || 3001
 
-app.listen(port, () => {
-  console.log(`🚀 Azify Logger rodando na porta ${port}`)
-})
+app.listen(port)
 
 process.on('SIGTERM', () => {
-  console.log('Received SIGTERM, shutting down')
   process.exit(0)
 })
 
 process.on('SIGINT', () => {
-  console.log('Received SIGINT, shutting down')
   process.exit(0)
 })
+