azify-logger 1.0.2

package/server.js

@@ -0,0 +1,229 @@
+require('./register-otel.js')
+
+const axios = require('axios')
+const express = require('express')
+const cors = require('cors')
+const os = require('os')
+const { trace, context, propagation } = require('@opentelemetry/api')
+const { W3CTraceContextPropagator } = require('@opentelemetry/core')
+
+const app = express()
+app.use(express.json())
+app.use(cors())
+
+const tracer = trace.getTracer('azify-logger', '1.0.0')
+const propagator = new W3CTraceContextPropagator()
+
+const traceContextMap = new Map()
+
+async function ensureIndex() {
+  const indexName = 'logs-azify'
+  const osUrl = process.env.OPENSEARCH_URL || 'http://localhost:9200'
+  try {
+    await axios.head(`${osUrl}/${indexName}`)
+    console.log(`✅ Índice ${indexName} já existe no OpenSearch`)
+    try {
+      await axios.post(`${osUrl}/${indexName}/_mapping`, {
+        properties: {
+          traceId: { type: 'keyword' },
+          spanId: { type: 'keyword' },
+          parentSpanId: { type: 'keyword' },
+          appName: { type: 'keyword' }
+        }
+      })
+    } catch (mapErr) {}
+  } catch (error) {
+    if (error.response?.status === 404) {
+      try {
+        await axios.put(`${osUrl}/${indexName}`, {
+          settings: {
+            number_of_shards: 1,
+            number_of_replicas: 0
+          },
+          mappings: {
+            properties: {
+              timestamp: { type: 'date' },
+              level: { type: 'keyword' },
+              message: { type: 'text' },
+              service: {
+                properties: {
+                  name: { type: 'keyword' },
+                  version: { 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' }
+                }
+              }
+            }
+          }
+        })
+        console.log(`✅ Índice ${indexName} criado no OpenSearch`)
+      } catch (createError) {
+        console.error('❌ Erro ao criar índice:', createError.message)
+      }
+    }
+  }
+}
+
+ensureIndex()
+
+function generateTraceId() {
+  return Math.random().toString(36).substring(2, 15) +
+         Math.random().toString(36).substring(2, 15)
+}
+
+function generateSpanId() {
+  return Math.random().toString(36).substring(2, 15)
+}
+
+function getOrCreateTraceContext(requestId) {
+  if (traceContextMap.has(requestId)) {
+    return traceContextMap.get(requestId)
+  }
+  
+  const traceContext = {
+    traceId: generateTraceId(),
+    spanId: generateSpanId(),
+    parentSpanId: null
+  }
+  
+  traceContextMap.set(requestId, traceContext)
+  
+  setTimeout(() => {
+    traceContextMap.delete(requestId)
+  }, 30000)
+  
+  return traceContext
+}
+
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', service: 'azify-logger' })
+})
+
+app.post('/log', async (req, res) => {
+  const { level, message, meta } = req.body
+  if (!level || !message) {
+    return res.status(400).json({ success: false, message: 'Level and message are required.' })
+  }
+
+  const requestId = meta?.requestId
+
+  let traceContext = null
+  
+  if (meta?.traceId && meta?.spanId) {
+    traceContext = {
+      traceId: meta.traceId,
+      spanId: meta.spanId,
+      parentSpanId: meta.parentSpanId || null
+    }
+  } else {
+    try {
+      const extractedCtx = propagation.extract(context.active(), req.headers, {
+        get (carrier, key) {
+          const header = carrier[key]
+          if (Array.isArray(header)) return header[0]
+          return header
+        },
+        keys (carrier) {
+          return Object.keys(carrier)
+        }
+      })
+
+      const spanContext = trace.getSpan(extractedCtx)?.spanContext?.() || null
+      if (spanContext && spanContext.traceId && spanContext.spanId) {
+        traceContext = {
+          traceId: spanContext.traceId,
+          spanId: spanContext.spanId,
+          parentSpanId: null
+        }
+      }
+    } catch (_) {}
+  }
+
+  if (!traceContext && requestId) {
+    traceContext = getOrCreateTraceContext(requestId)
+  }
+
+  if (!traceContext) {
+    traceContext = {
+      traceId: generateTraceId(),
+      spanId: generateSpanId(),
+      parentSpanId: null
+    }
+  }
+  
+  const logEntry = {
+    timestamp: meta?.timestamp || new Date().toISOString(),
+    level,
+    message,
+    service: {
+      name: meta?.service?.name || 'unknown-service',
+      version: meta?.service?.version || '1.0.0'
+    },
+    appName: meta?.appName || meta?.service?.name || undefined,
+    environment: meta?.environment || process.env.NODE_ENV || 'development',
+    hostname: meta?.hostname || os.hostname(),
+    traceId: traceContext.traceId,
+    spanId: traceContext.spanId,
+    parentSpanId: traceContext.parentSpanId
+  }
+
+  if (meta) {
+    Object.keys(meta).forEach(key => {
+      if (!['timestamp', 'service', 'environment', 'hostname', 'traceId', 'spanId', 'parentSpanId'].includes(key)) {
+        logEntry[key] = meta[key]
+      }
+    })
+  }
+
+  try {
+    const osUrl = process.env.OPENSEARCH_URL || 'http://localhost:9200'
+    await axios.post(`${osUrl}/logs-azify/_doc`, logEntry, {
+      headers: { 'Content-Type': 'application/json' }
+    })
+    
+    console.log(`✅ [${level.toUpperCase()}] ${message} | traceId: ${traceContext.traceId.substring(0, 8)}... | service: ${logEntry.service.name}`)
+    res.json({ success: true, message: 'Log enviado com sucesso' })
+  } 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' })
+  }
+})
+
+const port = process.env.PORT || 3000
+
+app.listen(port, () => {
+  console.log(`🚀 Azify Logger rodando na porta ${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)
+})

package/store.js

@@ -0,0 +1,42 @@
+const { AsyncLocalStorage } = require('async_hooks')
+
+const als = new AsyncLocalStorage()
+
+function generateId(bytes = 16) {
+  return require('crypto').randomBytes(bytes).toString('hex')
+}
+
+function toTraceId(hex32) {
+  // ensure 32 hex chars
+  const h = (hex32 || '').padStart(32, '0').slice(0, 32)
+  return `${h.substring(0, 8)}-${h.substring(8, 12)}-${h.substring(12, 16)}-${h.substring(16, 20)}-${h.substring(20, 32)}`
+}
+
+function startRequestContext(initial = {}) {
+  const traceHex = initial.traceHex || generateId(16) // 16 bytes -> 32 hex
+  const spanHex = initial.spanHex || generateId(8)    // 8 bytes -> 16 hex
+  const ctx = {
+    traceId: toTraceId(traceHex),
+    spanId: spanHex,
+    parentSpanId: initial.parentSpanId || null,
+    requestId: initial.requestId
+  }
+  return ctx
+}
+
+function runWithRequestContext(ctx, fn) {
+  return als.run(ctx, fn)
+}
+
+function getRequestContext() {
+  return als.getStore() || null
+}
+
+module.exports = {
+  als,
+  startRequestContext,
+  runWithRequestContext,
+  getRequestContext
+}
+
+

package/streams/bunyan.js

@@ -0,0 +1,60 @@
+const { AsyncLocalStorage } = require('async_hooks')
+const axios = require('axios')
+
+const globalContext = new Map()
+
+function createBunyanStream(options = {}) {
+  const loggerUrl = options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3000'
+  const serviceName = options.serviceName || process.env.APP_NAME || 'app'
+  const environment = options.environment || process.env.NODE_ENV || 'development'
+
+  return {
+    write(record) {
+      const level = (record.level >= 50) ? 'error'
+        : (record.level >= 40) ? 'warn'
+        : (record.level >= 30) ? 'info'
+        : (record.level >= 20) ? 'debug' : 'trace'
+
+      let traceId, spanId, requestId
+      
+      try {
+        const { getRequestContext } = require('../store')
+        const context = getRequestContext()
+        if (context) {
+          traceId = context.traceId
+          spanId = context.spanId
+          requestId = context.requestId
+        }
+      } catch (_) {}
+
+      if (!traceId || !spanId) {
+        requestId = record.requestId || record.req_id || record.reqId
+        if (requestId) {
+          const crypto = require('crypto')
+          const hash = crypto.createHash('sha256').update(String(requestId)).digest('hex')
+          traceId = `${hash.substring(0, 8)}-${hash.substring(8, 12)}-${hash.substring(12, 16)}-${hash.substring(16, 20)}-${hash.substring(20, 32)}`
+          spanId = hash.substring(0, 16)
+        }
+      }
+
+      const headers = {}
+
+      const meta = {
+        ...record,
+        service: { name: serviceName, version: record.service?.version || '1.0.0' },
+        environment,
+        timestamp: new Date().toISOString(),
+        hostname: require('os').hostname(),
+        requestId: requestId || record.requestId || record.req_id || record.reqId,
+        ...(traceId && { traceId }),
+        ...(spanId && { spanId })
+      }
+
+      const payload = { level, message: record.msg || record.message || 'log', meta }
+
+      axios.post(`${loggerUrl}/log`, payload, { headers, timeout: 3000 }).catch(() => {})
+    }
+  }
+}
+
+module.exports = createBunyanStream

package/streams/pino.js

@@ -0,0 +1,55 @@
+const { context, propagation, trace } = require('@opentelemetry/api')
+const { W3CTraceContextPropagator } = require('@opentelemetry/core')
+const axios = require('axios')
+
+function createPinoStream(options = {}) {
+  const loggerUrl = options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3000'
+  const serviceName = options.serviceName || process.env.APP_NAME || 'app'
+  const environment = options.environment || process.env.NODE_ENV || 'development'
+
+  return {
+    write(chunk) {
+      let record
+      try { record = typeof chunk === 'string' ? JSON.parse(chunk) : chunk } catch (_) { return }
+      const levelMap = { 60: 'fatal', 50: 'error', 40: 'warn', 30: 'info', 20: 'debug', 10: 'trace' }
+      const level = levelMap[record.level] || 'info'
+
+      let traceId, spanId
+      try {
+        const span = trace.getSpan(context.active())
+        const spanContext = span?.spanContext()
+        if (spanContext) {
+          traceId = spanContext.traceId
+          spanId = spanContext.spanId
+        }
+      } catch (_) {}
+
+      const headers = {}
+      try {
+        const propagator = new W3CTraceContextPropagator()
+        propagation.setGlobalPropagator(propagator)
+        propagation.inject(context.active(), headers, {
+          set (carrier, key, value) {
+            carrier[key] = value
+          }
+        })
+      } catch (_) {}
+
+      const meta = {
+        ...record,
+        service: { name: serviceName, version: record.service?.version || '1.0.0' },
+        environment,
+        timestamp: new Date().toISOString(),
+        hostname: require('os').hostname(),
+        requestId: record.requestId || record.req_id || record.reqId,
+        ...(traceId && { traceId }),
+        ...(spanId && { spanId })
+      }
+
+      const payload = { level, message: record.msg || record.message || 'log', meta }
+      axios.post(`${loggerUrl}/log`, payload, { headers, timeout: 3000 }).catch(() => {})
+    }
+  }
+}
+
+module.exports = createPinoStream