azify-logger 1.0.31 → 1.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",

package/register.js

@@ -84,11 +84,32 @@ try {
       return
     }
 
+    const metaCopy = { ...meta }
+    if (metaCopy.requestBody != null) {
+      if (typeof metaCopy.requestBody !== 'string') {
+        try {
+          metaCopy.requestBody = JSON.stringify(metaCopy.requestBody)
+        } catch (_) {
+          metaCopy.requestBody = String(metaCopy.requestBody)
+        }
+      }
+    }
+    
+    if (metaCopy.meta && metaCopy.meta.requestBody != null) {
+      if (typeof metaCopy.meta.requestBody !== 'string') {
+        try {
+          metaCopy.meta.requestBody = JSON.stringify(metaCopy.meta.requestBody)
+        } catch (_) {
+          metaCopy.meta.requestBody = String(metaCopy.meta.requestBody)
+        }
+      }
+    }
+
     const payload = {
       level,
       message,
       meta: {
-        ...meta,
+        ...metaCopy,
         service: {
           name: serviceName,
           version: (meta && meta.service && meta.service.version) || '1.0.0'
@@ -739,6 +760,7 @@ try {
   } catch (_) {}
 
   try {
+
     if (typeof globalThis.fetch === 'function') {
       const g = globalThis
       if (!g.__azifyLoggerFetchPatched) {
@@ -760,13 +782,60 @@ try {
             return originalFetch(input, init)
           }
           
-          const request = ensureRequest(input, init)
-          const method = request.method.toUpperCase()
-          const url = request.url
-
+          let url = 'unknown'
+          let method = 'GET'
+          
+          if (typeof input === 'string') {
+            url = input
+            method = (init?.method || 'GET').toUpperCase()
+          } else if (input instanceof URL) {
+            url = input.toString()
+            method = (init?.method || 'GET').toUpperCase()
+          } else if (typeof Request !== 'undefined' && input instanceof Request) {
+            url = input.url
+            method = input.method.toUpperCase()
+          } else {
+            try {
+              url = String(input)
+              method = (init?.method || 'GET').toUpperCase()
+            } catch (_) {
+              return originalFetch(input, init)
+            }
+          }
+          
           const testMeta = { url }
           if (isLoggerApiCall(testMeta)) {
-            return originalFetch(request)
+            return originalFetch(input, init)
+          }
+          
+          let requestBody = null
+          if (init && init.body != null) {
+            try {
+              const body = init.body
+              if (typeof body === 'string') {
+                requestBody = body
+              } else if (Buffer.isBuffer(body)) {
+                requestBody = body.toString('utf8')
+              } else if (body instanceof FormData) {
+                requestBody = '[FormData]'
+              } else if (body instanceof URLSearchParams) {
+                requestBody = body.toString()
+              } else if (typeof body === 'object' && body !== null) {
+                requestBody = JSON.stringify(body)
+              } else {
+                requestBody = String(body)
+              }
+            } catch (error) {
+              requestBody = null
+            }
+          } else if (typeof Request !== 'undefined' && input instanceof Request && input.body && !input.bodyUsed) {
+            try {
+              const cloned = input.clone()
+              const text = await cloned.text()
+              requestBody = text
+            } catch (_) {
+              requestBody = null
+            }
           }
 
           const ctx = getRequestContext()
@@ -775,11 +844,6 @@ try {
           const requestId = (ctx?.requestId) || randomUUID()
           const spanId = randomBytes(8).toString('hex')
 
-          request.headers.set('x-trace-id', traceId)
-          request.headers.set('x-span-id', spanId)
-          request.headers.set('x-parent-span-id', parentSpanId || '')
-          request.headers.set('x-request-id', requestId)
-
           const requestMeta = {
             traceId,
             spanId,
@@ -787,12 +851,131 @@ try {
             requestId,
             method,
             url,
-            headers: Object.fromEntries(request.headers.entries())
+            headers: {}
+          }
+
+          if (requestBody != null) {
+            let finalRequestBody = requestBody
+            if (typeof requestBody !== 'string') {
+              try {
+                finalRequestBody = JSON.stringify(requestBody)
+              } catch (_) {
+                finalRequestBody = String(requestBody)
+              }
+            }
+            requestMeta.requestBody = finalRequestBody
+          }
+
+          let request
+          try {
+            let headers
+            if (init?.headers instanceof Headers) {
+              headers = new Headers(init.headers)
+            } else if (init?.headers) {
+              headers = new Headers(init.headers)
+            } else {
+              headers = new Headers()
+            }
+            
+            headers.set('x-trace-id', traceId)
+            headers.set('x-span-id', spanId)
+            headers.set('x-parent-span-id', parentSpanId || '')
+            headers.set('x-request-id', requestId)
+            
+            requestMeta.headers = Object.fromEntries(headers.entries())
+            
+            request = ensureRequest(input, {
+              ...init,
+              headers: headers
+            })
+          } catch (error) {
+            if (init?.headers) {
+              try {
+                requestMeta.headers = typeof init.headers === 'object' && !(init.headers instanceof Headers)
+                  ? init.headers
+                  : Object.fromEntries(new Headers(init.headers).entries())
+              } catch (_) {
+                requestMeta.headers = {}
+              }
+            }
+            
+            markSource(requestMeta, 'http-client')
+            const hasTraceHeaders = !!(requestMeta.traceId && requestMeta.spanId)
+            const shouldLogRequest =
+              HTTP_CLIENT_MODE === 'all' ||
+              hasTraceHeaders
+
+            if (shouldLogRequest) {
+              if (hasTraceHeaders) {
+                const metaCopy = { ...requestMeta }
+                if (metaCopy.requestBody != null && typeof metaCopy.requestBody !== 'string') {
+                  try {
+                    metaCopy.requestBody = JSON.stringify(metaCopy.requestBody)
+                  } catch (_) {
+                    metaCopy.requestBody = String(metaCopy.requestBody)
+                  }
+                }
+                const payload = {
+                  level: 'info',
+                  message: `[REQUEST] ${method} ${url}`,
+                  meta: {
+                    ...metaCopy,
+                    service: {
+                      name: serviceName,
+                      version: '1.0.0'
+                    },
+                    environment,
+                    timestamp: new Date().toISOString(),
+                    hostname: os.hostname()
+                  }
+                }
+                transport.enqueue(payload, {
+                  'content-type': 'application/json'
+                })
+              } else {
+                sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+              }
+            }
+            
+            return originalFetch(input, init)
           }
 
           markSource(requestMeta, 'http-client')
-          if (HTTP_CLIENT_MODE === 'all') {
-            sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+          const hasTraceHeaders = !!(requestMeta.traceId && requestMeta.spanId)
+          const shouldLogRequest =
+            HTTP_CLIENT_MODE === 'all' ||
+            hasTraceHeaders
+
+          if (shouldLogRequest) {
+            if (hasTraceHeaders) {
+              const metaCopy = { ...requestMeta }
+              if (metaCopy.requestBody != null && typeof metaCopy.requestBody !== 'string') {
+                try {
+                  metaCopy.requestBody = JSON.stringify(metaCopy.requestBody)
+                } catch (_) {
+                  metaCopy.requestBody = String(metaCopy.requestBody)
+                }
+              }
+              const payload = {
+                level: 'info',
+                message: `[REQUEST] ${method} ${url}`,
+                meta: {
+                  ...metaCopy,
+                  service: {
+                    name: serviceName,
+                    version: '1.0.0'
+                  },
+                  environment,
+                  timestamp: new Date().toISOString(),
+                  hostname: os.hostname()
+                }
+              }
+              transport.enqueue(payload, {
+                'content-type': 'application/json'
+              })
+            } else {
+              sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+            }
           }
 
           const childCtx = {

package/scripts/redis-worker.js

@@ -226,6 +226,15 @@ function sanitizePayload(payload) {
     if (sanitized.meta.responseBody) {
       sanitized.meta.responseBody = sanitizeBody(sanitized.meta.responseBody)
     }
+    if (sanitized.meta.requestBody != null) {
+      if (typeof sanitized.meta.requestBody !== 'string') {
+        try {
+          sanitized.meta.requestBody = JSON.stringify(sanitized.meta.requestBody)
+        } catch (_) {
+          sanitized.meta.requestBody = String(sanitized.meta.requestBody)
+        }
+      }
+    }
   }
   
   return sanitized
@@ -248,6 +257,18 @@ async function deliver(entry) {
       sanitizedPayload = entry.payload
     }
   }
+  
+  if (sanitizedPayload && typeof sanitizedPayload === 'object' && sanitizedPayload.meta) {
+    if (sanitizedPayload.meta.requestBody != null) {
+      if (typeof sanitizedPayload.meta.requestBody !== 'string') {
+        try {
+          sanitizedPayload.meta.requestBody = JSON.stringify(sanitizedPayload.meta.requestBody)
+        } catch (_) {
+          sanitizedPayload.meta.requestBody = String(sanitizedPayload.meta.requestBody)
+        }
+      }
+    }
+  }
 
   await axios.post(target, sanitizedPayload, {
     headers: entry.headers || {},
@@ -325,6 +346,16 @@ async function processEntry(raw) {
     return
   }
 
+  if (entry && entry.payload && entry.payload.meta && entry.payload.meta.requestBody != null) {
+    if (typeof entry.payload.meta.requestBody !== 'string') {
+      try {
+        entry.payload.meta.requestBody = JSON.stringify(entry.payload.meta.requestBody)
+      } catch (_) {
+        entry.payload.meta.requestBody = String(entry.payload.meta.requestBody)
+      }
+    }
+  }
+
   const attempts = Number(entry.attempts || 0)
   try {
     await deliver(entry)

package/server.js

@@ -143,10 +143,18 @@ async function ensureIndexTemplate() {
               url: { type: 'keyword' },
               statusCode: { type: 'integer' },
               responseTime: { type: 'float' },
+              cpu: { type: 'float' },
+              cpuUsage: { type: 'float' },
+              memory: { type: 'float' },
+              memoryUsage: { type: 'float' },
+              totalMemory: { type: 'long' },
+              freeMemory: { type: 'long' },
+              usedMemory: { type: 'long' },
               ip: { type: 'ip' },
               userAgent: { type: 'text' },
               environment: { type: 'keyword' },
               hostname: { type: 'keyword' },
+              requestBody: { type: 'text' },
               responseBody: { type: 'text' },
               error: {
                 properties: {
@@ -404,7 +412,8 @@ async function setupGrafanaForApp(appName) {
         maxConcurrentShardRequests: 5,
         includeFrozen: false,
         xpack: false,
-        flavor: 'opensearch'
+        flavor: 'opensearch',
+        queryType: 'Lucene'
       },
       editable: true,
       version: 1
@@ -416,21 +425,8 @@ async function setupGrafanaForApp(appName) {
         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}`)
-      }
+      console.log(`[setupGrafana] Datasource existente encontrado: ${datasourceUid} (ID: ${existingResponse.data?.id || 'N/A'})`)
+      console.log(`[setupGrafana] ℹ️ Datasource já existe, mantendo configuração atual`)
     } 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) {
@@ -845,6 +841,621 @@ async function setupGrafanaForApp(appName) {
   }
 }
 
+async function getGrafanaClientConfig(apiTokenFromRequest) {
+  const runningInDocker = fs.existsSync('/.dockerenv')
+  const defaultGrafanaUrl = runningInDocker ? 'http://azify-grafana:3000' : 'http://127.0.0.1:3002'
+  const grafanaUrl = process.env.GRAFANA_URL || defaultGrafanaUrl
+
+  const apiToken = apiTokenFromRequest || process.env.GRAFANA_API_TOKEN
+
+  if (apiToken) {
+    const headers = {
+      Authorization: `Bearer ${apiToken}`
+    }
+    return { grafanaUrl, auth: null, headers }
+  }
+
+  const grafanaAdminUser = process.env.GRAFANA_ADMIN_USER || 'admin'
+  const grafanaAdminPassword =
+    process.env.GRAFANA_ADMIN_PASSWORD || process.env.GF_SECURITY_ADMIN_PASSWORD || 'admin'
+
+  const auth = {
+    username: grafanaAdminUser,
+    password: grafanaAdminPassword
+  }
+
+  return { grafanaUrl, auth, headers: null }
+}
+
+async function registerAlertRulesForApp(appName, rules, options = {}) {
+  if (!appName || !Array.isArray(rules) || rules.length === 0) {
+    throw new Error('appName e pelo menos uma rule são obrigatórios')
+  }
+
+  const serviceName = appName.toLowerCase().replace(/[^a-z0-9-]/g, '-')
+
+  console.log(`[alerts] 🔍 Iniciando registro de alertas para app=${appName} (serviceName=${serviceName})`)
+
+  await setupGrafanaForApp(serviceName)
+
+  const { grafanaUrl, auth, headers } = await getGrafanaClientConfig(options?.grafanaApiToken)
+  
+  console.log(`[alerts] 🔗 Conectando ao Grafana: ${grafanaUrl}`)
+
+  const makeGrafanaRequestConfig = (extra = {}) => {
+    const cfg = {
+      timeout: 5000,
+      ...extra
+    }
+
+    if (auth) {
+      cfg.auth = auth
+    }
+    if (headers) {
+      cfg.headers = {
+        ...headers,
+        ...(extra.headers || {})
+      }
+    }
+
+    return cfg
+  }
+
+  console.log(`[alerts] 🔍 Buscando organização: ${serviceName}`)
+  const orgResp = await axios.get(
+    `${grafanaUrl}/api/orgs/name/${encodeURIComponent(serviceName)}`,
+    makeGrafanaRequestConfig()
+  )
+
+  const orgId = orgResp.data && orgResp.data.id
+  if (!orgId) {
+    throw new Error(`Org não encontrada para app ${serviceName}`)
+  }
+  
+  console.log(`[alerts] ✅ Organização encontrada: ${serviceName} (orgId=${orgId})`)
+
+  const datasourceUid = `opensearch-${serviceName}`
+  const indexFilter = `_index:logs-${serviceName}`
+
+  async function createOrUpdateContactPointForRule(rule) {
+    const notify = rule.notify || {}
+    const explicitReceiver =
+      notify.receiverName || notify.receiver || null
+
+    if (explicitReceiver) {
+      return explicitReceiver
+    }
+
+    const teamsWebhooks = Array.isArray(notify.teamsWebhooks)
+      ? notify.teamsWebhooks.filter(Boolean)
+      : []
+    const emails = Array.isArray(notify.emails)
+      ? notify.emails.filter(Boolean)
+      : []
+
+    if (teamsWebhooks.length === 0 && emails.length === 0) {
+      return null
+    }
+
+    let primaryReceiver = null
+
+    if (teamsWebhooks.length > 0) {
+      const cpName = `alerts-${serviceName}-${rule.id}-teams`
+      try {
+        const existing = await axios.get(
+          `${grafanaUrl}/api/v1/provisioning/contact-points`,
+          makeGrafanaRequestConfig({
+            headers: { 'X-Grafana-Org-Id': orgId }
+          })
+        )
+
+        const found = Array.isArray(existing.data)
+          ? existing.data.find(cp => cp.name === cpName)
+          : null
+
+        const payload = {
+          name: cpName,
+          type: 'teams',
+          settings: {
+            url: teamsWebhooks[0]
+          },
+          disableResolveMessage: false
+        }
+
+        if (found && found.uid) {
+          await axios.put(
+            `${grafanaUrl}/api/v1/provisioning/contact-points/${encodeURIComponent(found.uid)}`,
+            payload,
+            makeGrafanaRequestConfig({
+              headers: { 'X-Grafana-Org-Id': orgId, 'Content-Type': 'application/json' }
+            })
+          )
+          console.log(`[alerts] ✅ Contact point Teams atualizado: ${cpName}`)
+        } else {
+          await axios.post(
+            `${grafanaUrl}/api/v1/provisioning/contact-points`,
+            payload,
+            makeGrafanaRequestConfig({
+              headers: { 'X-Grafana-Org-Id': orgId, 'Content-Type': 'application/json' }
+            })
+          )
+          console.log(`[alerts] ✅ Contact point Teams criado: ${cpName}`)
+        }
+
+        if (!primaryReceiver) primaryReceiver = cpName
+      } catch (err) {
+        const status = err?.response?.status || 'N/A'
+        const msg = err?.response?.data?.message || err.message
+        console.error(`[alerts] ❌ Erro ao criar/atualizar contact point Teams ${cpName}: ${msg} (status=${status})`)
+      }
+    }
+
+    if (emails.length > 0) {
+      const cpName = `alerts-${serviceName}-${rule.id}-email`
+      try {
+        const existing = await axios.get(
+          `${grafanaUrl}/api/v1/provisioning/contact-points`,
+          makeGrafanaRequestConfig({
+            headers: { 'X-Grafana-Org-Id': orgId }
+          })
+        )
+
+        const found = Array.isArray(existing.data)
+          ? existing.data.find(cp => cp.name === cpName)
+          : null
+
+        const payload = {
+          name: cpName,
+          type: 'email',
+          settings: {
+            addresses: emails.join(',')
+          },
+          disableResolveMessage: false
+        }
+
+        if (found && found.uid) {
+          await axios.put(
+            `${grafanaUrl}/api/v1/provisioning/contact-points/${encodeURIComponent(found.uid)}`,
+            payload,
+            makeGrafanaRequestConfig({
+              headers: { 'X-Grafana-Org-Id': orgId, 'Content-Type': 'application/json' }
+            })
+          )
+          console.log(`[alerts] ✅ Contact point Email atualizado: ${cpName}`)
+        } else {
+          await axios.post(
+            `${grafanaUrl}/api/v1/provisioning/contact-points`,
+            payload,
+            makeGrafanaRequestConfig({
+              headers: { 'X-Grafana-Org-Id': orgId, 'Content-Type': 'application/json' }
+            })
+          )
+          console.log(`[alerts] ✅ Contact point Email criado: ${cpName}`)
+        }
+
+        if (!primaryReceiver) primaryReceiver = cpName
+      } catch (err) {
+        const status = err?.response?.status || 'N/A'
+        const msg = err?.response?.data?.message || err.message
+        console.error(`[alerts] ❌ Erro ao criar/atualizar contact point Email ${cpName}: ${msg} (status=${status})`)
+      }
+    }
+
+    return primaryReceiver
+  }
+
+  async function upsertNotificationPolicyForRule(alertId, receiverName) {
+    if (!receiverName) return
+
+    try {
+      const resp = await axios.get(
+        `${grafanaUrl}/api/v1/provisioning/policies`,
+        makeGrafanaRequestConfig({
+          headers: { 'X-Grafana-Org-Id': orgId }
+        })
+      )
+
+      let tree = resp.data || {}
+
+      if (!tree.receiver && !tree.routes) {
+        tree = {
+          receiver: receiverName,
+          group_by: ['alertname'],
+          routes: []
+        }
+      }
+
+      if (!Array.isArray(tree.routes)) {
+        tree.routes = []
+      }
+
+      const matchers = [
+        `appName=~${serviceName}`,
+        `alertId=~${alertId}`
+      ]
+
+      const routeMatches = (route) => {
+        if (!Array.isArray(route.matchers)) return false
+        return route.matchers.some(m => 
+          (typeof m === 'string' && m.includes(`alertId=~${alertId}`)) ||
+          (typeof m === 'object' && m.value === alertId)
+        )
+      }
+
+      let existingRoute = tree.routes.find(routeMatches)
+
+      if (existingRoute) {
+        existingRoute.receiver = receiverName
+        if (!Array.isArray(existingRoute.matchers)) {
+          existingRoute.matchers = matchers
+        }
+        existingRoute.group_wait = '5s'
+        console.log(`[alerts] ✅ Notification policy atualizada para alertId=${alertId}, receiver=${receiverName}`)
+      } else {
+        tree.routes.push({
+          receiver: receiverName,
+          matchers: matchers,
+          continue: false,
+          group_by: [],
+          group_wait: '5s',
+          group_interval: '5m',
+          repeat_interval: '1h'
+        })
+        console.log(`[alerts] ✅ Notification policy criada para alertId=${alertId}, receiver=${receiverName}`)
+      }
+
+      console.log(`[alerts] 📤 Atualizando notification policy tree:`, JSON.stringify(tree, null, 2))
+      await axios.put(
+        `${grafanaUrl}/api/v1/provisioning/policies`,
+        tree,
+        makeGrafanaRequestConfig({
+          headers: { 'X-Grafana-Org-Id': orgId, 'Content-Type': 'application/json' }
+        })
+      )
+      console.log(`[alerts] ✅ Notification policy tree atualizada com sucesso`)
+    } catch (err) {
+      const status = err?.response?.status || 'N/A'
+      const msg = err?.response?.data?.message || err.message
+      console.log(`[alerts] ⚠️ Aviso ao atualizar notification policies para app=${serviceName}, alertId=${alertId}: ${msg} (status=${status})`)
+    }
+  }
+
+  async function ensureAlertFolderForApp() {
+    const folderUid = `alerts-${serviceName}`
+    const folderTitle = `Alerts - ${serviceName}`
+
+    try {
+      const existing = await axios.get(
+        `${grafanaUrl}/api/folders/${encodeURIComponent(folderUid)}`,
+        makeGrafanaRequestConfig({
+          headers: { 'X-Grafana-Org-Id': orgId }
+        })
+      )
+      if (existing.data && existing.data.uid) {
+        return existing.data.uid
+      }
+    } catch (err) {
+      if (err?.response?.status !== 404) {
+        console.error(`[alerts] ⚠️ Erro ao buscar pasta de alertas: ${err.message}`)
+      }
+    }
+
+    try {
+      const created = await axios.post(
+        `${grafanaUrl}/api/folders`,
+        { uid: folderUid, title: folderTitle },
+        makeGrafanaRequestConfig({
+          headers: { 'X-Grafana-Org-Id': orgId, 'Content-Type': 'application/json' }
+        })
+      )
+      if (created.data && created.data.uid) {
+        console.log(`[alerts] ✅ Pasta de alertas criada: ${folderTitle} (uid=${created.data.uid})`)
+        return created.data.uid
+      }
+    } catch (err) {
+      const status = err?.response?.status || 'N/A'
+      if (status !== 409) {
+        console.error(`[alerts] ❌ Erro ao criar pasta de alertas: ${err.message} (status=${status})`)
+      } else {
+        console.log(`[alerts] ℹ️ Pasta de alertas já existe: ${folderTitle}`)
+      }
+    }
+
+    return folderUid
+  }
+
+  const alertFolderUid = await ensureAlertFolderForApp()
+
+  for (const rule of rules) {
+    const id = rule.id
+    if (!id) continue
+
+    const title = rule.title || rule.description || id
+    const description = rule.description || `Alert rule ${id} for ${serviceName}`
+    const severity = rule.severity || 'warning'
+    const window = rule.window || '5m'
+    const query = rule.query || '*'
+
+    const rawQueryType = (rule.queryType || 'PPL').toString()
+    const normalizedQueryType =
+      rawQueryType.toLowerCase() === 'lucene' ? 'lucene' : 'PPL'
+    const isPPL = normalizedQueryType === 'PPL'
+    const isLucene = normalizedQueryType === 'lucene'
+
+    let fullQuery = query
+    if (isLucene && (!query || query.trim() === '*')) {
+      fullQuery = indexFilter
+    }
+
+    const usesStats = isPPL && /stats\s+/.test(query.toLowerCase())
+    const isReducedData = usesStats && !/stats\s+[^|]*\s+by\s+@timestamp/i.test(query)
+
+    let windowSeconds = 300
+    const match = /^(\d+)([smhd])$/.exec(window)
+    if (match) {
+      const value = parseInt(match[1], 10)
+      const unit = match[2]
+      if (unit === 's') windowSeconds = value
+      if (unit === 'm') windowSeconds = value * 60
+      if (unit === 'h') windowSeconds = value * 60 * 60
+      if (unit === 'd') windowSeconds = value * 60 * 60 * 24
+    }
+    
+    const relativeTimeRangeSeconds = Math.max(windowSeconds, 300) // 5 minutos mínimo
+
+    const receiverName = await createOrUpdateContactPointForRule(rule)
+
+    let metrics
+    let bucketAggs = []
+
+    if (isPPL && isReducedData) {
+      metrics = [
+        {
+          id: '1',
+          type: 'avg',
+          field: 'value'
+        }
+      ]
+      bucketAggs = []
+    } else if (isLucene) {
+      metrics = [
+        {
+          id: '1',
+          type: 'count'
+        }
+      ]
+      bucketAggs = [
+        {
+          id: '2',
+          type: 'date_histogram',
+          field: '@timestamp',
+          settings: {
+            interval: 'auto',
+            min_doc_count: 0
+          }
+        }
+      ]
+    } else {
+      metrics = [
+        {
+          id: '1',
+          type: 'count'
+        }
+      ]
+      bucketAggs = []
+    }
+
+    let timeField = '@timestamp'
+    if (
+      isPPL &&
+      isReducedData &&
+      /max\(@timestamp\)\s+as\s+timestamp/i.test(query)
+    ) {
+      timeField = 'timestamp'
+    }
+
+    let data
+    let condition
+
+    if (isLucene) {
+      const queryA = {
+        refId: 'A',
+        queryType: 'lucene',
+        relativeTimeRange: {
+          from: relativeTimeRangeSeconds,
+          to: 0
+        },
+        datasourceUid,
+        datasource: {
+          type: 'grafana-opensearch-datasource',
+          uid: datasourceUid
+        },
+        model: {
+          alias: '',
+          bucketAggs: [
+            {
+              field: '@timestamp',
+              id: '2',
+              settings: {
+                interval: 'auto'
+              },
+              type: 'date_histogram'
+            }
+          ],
+          format: 'table',
+          intervalMs: 1000,
+          luceneQueryType: 'Metric',
+          maxDataPoints: 43200,
+          metrics: [
+            {
+              id: '1',
+              type: 'count'
+            }
+          ],
+          query: fullQuery,
+          queryType: 'lucene',
+          refId: 'A',
+          timeField: '@timestamp'
+        }
+      }
+
+      const exprB = {
+        refId: 'B',
+        queryType: '',
+        relativeTimeRange: {
+          from: 0,
+          to: 0
+        },
+        datasourceUid: '__expr__',
+        model: {
+          datasource: {
+            type: '__expr__',
+            uid: '__expr__'
+          },
+          expression: 'A',
+          intervalMs: 1000,
+          maxDataPoints: 43200,
+          reducer: 'sum',
+          refId: 'B',
+          type: 'reduce'
+        }
+      }
+
+      const exprC = {
+        refId: 'C',
+        queryType: '',
+        relativeTimeRange: {
+          from: 0,
+          to: 0
+        },
+        datasourceUid: '__expr__',
+        model: {
+          datasource: {
+            type: '__expr__',
+            uid: '__expr__'
+          },
+          expression: 'B',
+          intervalMs: 1000,
+          maxDataPoints: 43200,
+          refId: 'C',
+          type: 'threshold',
+          conditions: [
+            {
+              evaluator: {
+                params: [0],
+                type: 'gt'
+              },
+              operator: {
+                type: 'and'
+              },
+              query: {
+                params: ['C']
+              },
+              reducer: {
+                params: [],
+                type: 'last'
+              },
+              type: 'query'
+            }
+          ]
+        }
+      }
+
+      data = [queryA, exprB, exprC]
+      condition = 'C'
+    } else {
+      data = [
+        {
+          refId: 'A',
+          datasourceUid,
+          datasource: {
+            type: 'grafana-opensearch-datasource',
+            uid: datasourceUid
+          },
+          queryType: normalizedQueryType,
+          relativeTimeRange: {
+            from: windowSeconds,
+            to: 0
+          },
+          model: {
+            refId: 'A',
+            query: fullQuery,
+            queryType: normalizedQueryType,
+            metrics,
+            bucketAggs,
+            timeField
+          }
+        }
+      ]
+      condition = 'A'
+    }
+
+    const payload = {
+      uid: `${serviceName}-${id}`,
+      title,
+      condition,
+      data,
+      noDataState: 'NoData',
+      execErrState: 'Error',
+      for: window,
+      folderUid: alertFolderUid,
+      labels: {
+        appName: serviceName,
+        severity,
+        alertId: id,
+        source: 'azify-logger-alerts'
+      },
+      annotations: {
+        summary: title,
+        description
+      },
+      ruleGroup: `alerts-${serviceName}`,
+      orgId
+    }
+
+      try {
+        console.log(`[alerts] Registrando regra '${id}' para app=${serviceName}, severity=${severity}`)
+
+        try {
+          await axios.delete(
+            `${grafanaUrl}/api/v1/provisioning/alert-rules/${payload.uid}`,
+            makeGrafanaRequestConfig({
+              headers: {
+                'X-Grafana-Org-Id': orgId
+              }
+            })
+          )
+        console.log(`[alerts] ℹ️ Regra '${id}' deletada (será recriada)`)
+      } catch (deleteErr) {
+        if (deleteErr?.response?.status !== 404) {
+          console.log(`[alerts] ⚠️ Erro ao deletar regra (continuando): ${deleteErr.message}`)
+        }
+      }
+
+        await axios.post(
+          `${grafanaUrl}/api/v1/provisioning/alert-rules`,
+          payload,
+          makeGrafanaRequestConfig({
+            headers: {
+              'X-Grafana-Org-Id': orgId,
+              'Content-Type': 'application/json'
+            },
+            timeout: 10000
+          })
+        )
+      console.log(`[alerts] ✅ Regra '${id}' criada para app=${serviceName}`)
+
+      if (receiverName) {
+        await upsertNotificationPolicyForRule(id, receiverName)
+      }
+    } catch (err) {
+      const status = err?.response?.status || 'N/A'
+      const msg = err?.response?.data?.message || err.message
+      console.error(`[alerts] ❌ Falha ao registrar regra '${id}' para app=${serviceName}: ${msg} (status=${status})`)
+    }
+  }
+}
+
 function generateTraceId() {
   return Math.random().toString(36).substring(2, 15) +
          Math.random().toString(36).substring(2, 15)
@@ -1081,28 +1692,16 @@ async function handleLog(req, res) {
           }
           
           if (typeof bodyValue === 'string') {
-            if (bodyValue.trim().startsWith('{') || bodyValue.trim().startsWith('[')) {
-              try {
-                let parsed = JSON.parse(bodyValue)
-                if (typeof parsed === 'object') {
-                  return parsed
-                }
-              } catch (_) { }
-            }
             return bodyValue
           } else if (typeof bodyValue === 'object' && bodyValue !== null) {
-            return bodyValue
+            try {
+              return JSON.stringify(bodyValue)
+            } catch (_) {
+              return String(bodyValue)
+            }
           } else if (Buffer.isBuffer(bodyValue)) {
             try {
-              let str = bodyValue.toString('utf8')
-              if (str.trim().startsWith('{') || str.trim().startsWith('[')) {
-                try {
-                  return JSON.parse(str)
-                } catch (_) {
-                  return str
-                }
-              }
-              return str
+              return bodyValue.toString('utf8')
             } catch (_) {
               return '[Unable to serialize Buffer]'
             }
@@ -1233,6 +1832,183 @@ app.post('/v1/traces', async (req, res) => {
 })
 app.post('/send', (req, res) => handleLog(req, res))
 
+app.post('/alerts/register', async (req, res) => {
+  try {
+    const { appName, rules, grafanaApiToken } = req.body || {}
+
+    if (!appName || !Array.isArray(rules) || rules.length === 0) {
+      return res.status(400).json({
+        success: false,
+        message: 'Parâmetros inválidos. É necessário enviar appName e uma lista não vazia de rules.'
+      })
+    }
+
+    console.log(`[alerts] 📥 Recebido registro de alertas para app=${appName}, ${rules.length} regra(s)`)
+    
+    const results = await registerAlertRulesForApp(appName, rules, { grafanaApiToken })
+
+    res.json({
+      success: true,
+      message: 'Regras de alerta processadas com sucesso para a aplicação.',
+      appName,
+      rulesProcessed: rules.length,
+      details: results
+    })
+  } catch (error) {
+    const message = error?.message || 'Erro desconhecido ao registrar alertas'
+    console.error('[alerts] ❌ Erro no endpoint /alerts/register:', message)
+    if (error.stack) {
+      console.error('[alerts] Stack:', error.stack.substring(0, 500))
+    }
+    res.status(500).json({
+      success: false,
+      message
+    })
+  }
+})
+
+app.post('/dashboards/register', async (req, res) => {
+  try {
+    const { appName, dashboard } = req.body || {}
+
+    if (!appName) {
+      return res.status(400).json({
+        success: false,
+        message: 'appName is required'
+      })
+    }
+
+    if (!dashboard || !dashboard.dashboard) {
+      return res.status(400).json({
+        success: false,
+        message: 'dashboard object is required'
+      })
+    }
+
+    console.log(`[dashboards] 📥 Recebido registro de dashboard para app=${appName}`)
+
+    await setupGrafanaForApp(appName)
+
+    const runningInDocker = fs.existsSync('/.dockerenv')
+    const defaultGrafanaUrl = runningInDocker ? 'http://azify-grafana:3000' : 'http://127.0.0.1:3002'
+    const grafanaUrl = process.env.GRAFANA_URL || defaultGrafanaUrl
+    const grafanaAdminUser = process.env.GRAFANA_ADMIN_USER || 'admin'
+    const grafanaAdminPassword = process.env.GRAFANA_ADMIN_PASSWORD || process.env.GF_SECURITY_ADMIN_PASSWORD || 'admin'
+
+    const auth = {
+      username: grafanaAdminUser,
+      password: grafanaAdminPassword
+    }
+
+    const orgResponse = await axios.get(`${grafanaUrl}/api/orgs/name/${encodeURIComponent(appName)}`, {
+      auth,
+      timeout: 3000
+    })
+
+    const org = orgResponse.data
+    const orgId = org.id
+
+    const datasourceUid = `opensearch-${appName.toLowerCase()}`
+    
+    const dashboardConfig = {
+      ...dashboard,
+      overwrite: true,
+      folderId: null
+    }
+
+    const replaceDatasourceUid = (obj) => {
+      if (typeof obj === 'string') {
+        return obj.replace(/\$\{DS_OPENSEARCH\}/g, datasourceUid)
+      }
+      if (Array.isArray(obj)) {
+        return obj.map(replaceDatasourceUid)
+      }
+      if (obj && typeof obj === 'object') {
+        const result = {}
+        for (const key in obj) {
+          if (key === 'datasource' && obj[key] && typeof obj[key] === 'object') {
+            if (obj[key].uid === '${DS_OPENSEARCH}' || obj[key].uid?.includes('DS_OPENSEARCH')) {
+              result[key] = {
+                ...obj[key],
+                uid: datasourceUid,
+                type: obj[key].type || 'grafana-opensearch-datasource'
+              }
+            } else {
+              result[key] = replaceDatasourceUid(obj[key])
+            }
+          } else {
+            result[key] = replaceDatasourceUid(obj[key])
+          }
+        }
+        return result
+      }
+      return obj
+    }
+
+    if (dashboardConfig.dashboard) {
+      dashboardConfig.dashboard = replaceDatasourceUid(dashboardConfig.dashboard)
+    }
+
+    try {
+      const searchResponse = await axios.get(`${grafanaUrl}/api/search?query=${encodeURIComponent(dashboard.dashboard.title)}&type=dash-db`, {
+        auth,
+        headers: { 'X-Grafana-Org-Id': orgId },
+        timeout: 3000
+      })
+
+      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': orgId },
+          timeout: 3000
+        })
+
+        if (dashboardConfig.dashboard) {
+          dashboardConfig.dashboard.id = dashboardDetail.data.dashboard.id
+          dashboardConfig.dashboard.uid = dashboardDetail.data.dashboard.uid
+          dashboardConfig.dashboard.version = dashboardDetail.data.dashboard.version
+        }
+      }
+    } catch (searchError) {
+    }
+
+    const dashboardResponse = await axios.post(
+      `${grafanaUrl}/api/dashboards/db`,
+      dashboardConfig,
+      {
+        auth,
+        headers: { 'X-Grafana-Org-Id': orgId, 'Content-Type': 'application/json' },
+        timeout: 10000
+      }
+    )
+
+    console.log(`[dashboards] ✅ Dashboard criado: ${dashboardResponse.data?.dashboard?.title || 'N/A'} (UID: ${dashboardResponse.data?.dashboard?.uid || 'N/A'})`)
+
+    res.json({
+      success: true,
+      message: 'Dashboard registrado com sucesso',
+      appName,
+      data: {
+        dashboardId: dashboardResponse.data.id,
+        dashboardUid: dashboardResponse.data.uid,
+        url: dashboardResponse.data.url,
+        title: dashboardResponse.data.dashboard?.title
+      }
+    })
+  } catch (error) {
+    const message = error?.response?.data?.message || error?.message || 'Erro desconhecido ao registrar dashboard'
+    console.error('[dashboards] ❌ Erro no endpoint /dashboards/register:', message)
+    if (error.stack) {
+      console.error('[dashboards] Stack:', error.stack.substring(0, 500))
+    }
+    res.status(error?.response?.status || 500).json({
+      success: false,
+      message
+    })
+  }
+})
+
 const port = process.env.PORT || 3001
 
 app.listen(port)