azify-logger 1.0.2

package/README.md

@@ -0,0 +1,295 @@
+# 🚀 Azify Logger - Logging Centralizado
+
+Sistema de logging centralizado com OpenTelemetry e OpenSearch para múltiplas aplicações.
+
+## 📦 Instalação
+
+Na sua aplicação, adicione ao `package.json`:
+
+```json
+{
+  "dependencies": {
+    "azify-logger": "latest"
+  }
+}
+```
+
+Ou via npm:
+
+```bash
+npm install azify-logger
+```
+
+## ⚡ Utilização
+
+### Para aplicações Restify:
+
+**1. No arquivo de inicialização:**
+```javascript
+#!/usr/bin/env node
+require('azify-logger/register-otel');
+// Resto do código...
+```
+
+**2. No servidor Restify:**
+```javascript
+import { middleware as azifyMiddleware } from 'azify-logger'
+
+const server = restify.createServer()
+server.use(azifyMiddleware.restify())
+```
+
+**3. Variável de ambiente:**
+```bash
+APP_NAME=nome-app
+```
+
+**PRONTO! 🎉** 
+
+### Para aplicações Express:
+
+```javascript
+require('azify-logger')
+
+const express = require('express')
+const app = express()
+// Logs automáticos via OpenTelemetry
+```
+
+### ❌ O que NÃO precisa:
+- ❌ Instalar dependências OpenTelemetry separadamente
+- ❌ Configurar tracing manualmente
+
+## ⚙️ Variáveis de Ambiente
+
+| Variável | Padrão | Descrição |
+|----------|-------|-----------|
+| `APP_NAME` | - | Nome da aplicação |
+| `AZIFY_LOGGER_URL` | `http://localhost:3000` | URL do logger |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://localhost:4318/v1/traces` | OTLP endpoint |
+| `NODE_ENV` | `development` | Ambiente |
+| `AZIFY_LOGGER_AUTOREG_DISABLE` | `""` | Se `"1"`, desativa auto-registro do OTEL |
+
+**Para desenvolvimento local:** só precisa de `APP_NAME` (o resto usa defaults)
+
+**Para produção:** configure todas as URLs apontando para servidores de produção
+
+### Docker e Node antigos
+
+Se seu container usa uma versão antiga do Node e você ver erros de inicialização do OpenTelemetry (ex.: `Cannot find module 'node:events'` saindo de `google-logging-utils` ou `@opentelemetry/resource-detector-gcp`), defina no container:
+
+```bash
+AZIFY_LOGGER_AUTOREG_DISABLE=1
+```
+
+Isso evita carregar `register-otel.js` e mantém os envios de log via streams/middleware normalmente, permitindo visualização no OpenSearch.
+
+## 🎯 O Que Você Ganha
+
+- ✅ **Zero Config**: OpenTelemetry habilitado automaticamente
+- ✅ **Logs Completos**: Headers, body, query params, status
+- ✅ **Trace Consistente**: REQUEST e RESPONSE com mesmo traceId/spanId
+- ✅ **Genérico**: Funciona com Bunyan, Pino, console.log ou qualquer logger
+- ✅ **Centralizado**: Todos os logs no OpenSearch
+
+## 🔧 Uso Avançado
+
+### Com Bunyan existente (adicionar stream)
+
+Se sua app **já tem Bunyan** e você quer adicionar o azify-logger como stream adicional:
+
+```javascript
+// Forma segura com try/catch (não quebra se não tiver instalado)
+let createAzifyBunyanStream
+try {
+  createAzifyBunyanStream = require('azify-logger/streams/bunyan')
+} catch (_) {
+  createAzifyBunyanStream = null
+}
+
+const bunyan = require('bunyan')
+const streams = [
+  { level: 'info', stream: process.stdout }
+]
+
+// Adiciona stream do azify-logger se disponível
+if (createAzifyBunyanStream) {
+  streams.push({
+    level: 'info',
+    type: 'raw',
+    stream: createAzifyBunyanStream({
+      loggerUrl: process.env.AZIFY_LOGGER_URL || 'http://localhost:3000',
+      serviceName: process.env.APP_NAME || 'app'
+    })
+  })
+}
+
+const logger = bunyan.createLogger({ name: 'app', streams })
+logger.info('Teste')  // Vai para stdout E para azify-logger
+```
+
+### Com Bunyan (auto-patch - mais simples)
+
+```javascript
+require('azify-logger')
+
+const bunyan = require('bunyan')
+const log = bunyan.createLogger({ name: 'nome-app' })
+
+log.info('Teste')  // Automaticamente enviado para azify-logger
+```
+
+### Com Pino
+
+```javascript
+const { streams } = require('azify-logger')
+const pino = require('pino')
+
+const logger = pino({ level: 'info' }, streams.createPinoStream({
+  loggerUrl: 'http://localhost:3000',
+  serviceName: 'nome-app'
+}))
+
+logger.info('Teste')
+```
+
+### Logger Direto (sem Bunyan/Pino)
+
+```javascript
+const { createAzifyLogger } = require('azify-logger')
+
+const logger = createAzifyLogger({
+  serviceName: 'nome-app',
+  loggerUrl: 'http://localhost:3000'
+})
+
+logger.info('Mensagem', { userId: '123' })
+logger.error('Erro', new Error('Falha'), { context: 'payment' })
+```
+
+---
+
+## 🛠️ Setup do Serviço de Logging (Infra)
+
+Se você precisa subir a infraestrutura do azify-logger:
+
+### 1. Iniciar serviços
+
+```bash
+./start-docker.sh
+```
+
+Aguarde alguns minutos. Você verá:
+
+```
+✅ Tudo pronto!
+📊 OpenSearch: http://localhost:9200
+🎨 OpenSearch Dashboards: http://localhost:5601
+📝 Logger API: http://localhost:3000
+🔭 OTEL Collector: http://localhost:4318
+```
+
+### 2. Testar
+
+```bash
+curl -X POST http://localhost:3000/log \
+  -H "Content-Type: application/json" \
+  -d '{
+    "level": "info",
+    "message": "Teste",
+    "meta": {"service": {"name": "teste"}}
+  }'
+```
+
+### 3. Ver logs
+
+**OpenSearch Dashboards:**
+```bash
+http://localhost:5601
+```
+
+**Como usar:**
+Acesse: http://localhost:5601
+
+## 📊 Estrutura dos Logs
+
+Cada log no OpenSearch contém:
+
+```json
+{
+  "timestamp": "2025-10-01T10:15:30.123Z",
+  "level": "info",
+  "message": "[REQUEST] POST /api/payment",
+  "service": {
+    "name": "nome-app",
+    "version": "1.0.0"
+  },
+  "traceId": "abc123...",
+  "spanId": "xyz789...",
+  "method": "POST",
+  "url": "/api/payment",
+  "requestBody": { ... },
+  "statusCode": 200,
+  "responseTime": 123.45,
+  "responseBody": { ... },
+  "environment": "production",
+  "hostname": "app-server-01"
+}
+```
+
+## 🔍 Como Funciona
+
+1. **OpenTelemetry** cria um span para cada request HTTP
+2. **Middleware** captura request e response com o **mesmo span ativo**
+3. **Logger** envia ambos os logs com **traceId e spanId iguais**
+4. **OpenSearch** indexa e permite buscar por traceId
+
+## 📖 Arquitetura
+
+```
+┌─────────────┐
+│  aplicação  │  
+└──────┬──────┘
+       │ HTTP POST
+       ↓
+┌─────────────┐
+│ azify-logger│  (recebe logs)
+└──────┬──────┘
+       │
+       ↓
+┌─────────────┐
+│ OpenSearch  │  (armazena)
+└──────┬──────┘
+       │
+       ↓
+┌─────────────┐
+│  Dashboards |
+|  OpenSearch │ (visualiza)
+└─────────────┘
+```
+
+## 📈 OpenSearch Dashboards
+
+O azify-logger usa OpenSearch Dashboards para visualização dos logs:
+
+### 🎯 Funcionalidades Disponíveis
+
+1. **📊 Discover** - Visualização e busca de logs
+   - Filtros por serviço, app, traceId, statusCode
+   - Busca em tempo real
+   - Visualização detalhada de cada log
+
+2. **📈 Dashboard** - "Application Health Dashboard"
+   - **Taxa de Sucesso** - Percentual de requisições 2xx
+   - **Latência Média** - Tempo médio de resposta
+   - **Erros 4xx/5xx** - Contador de erros
+   - **Requisições por Minuto** - Gráfico temporal
+
+### 🚀 Acesso
+
+```bash
+# Local
+http://localhost:5601
+
+# Sem autenticação necessária (desenvolvimento)
+```

package/index.js

@@ -0,0 +1,114 @@
+const axios = require('axios')
+const { context, propagation, trace } = require('@opentelemetry/api')
+const { W3CTraceContextPropagator } = require('@opentelemetry/core')
+
+if (process.env.AZIFY_LOGGER_AUTOREG_DISABLE !== '1') {
+  try { require('./register-otel') } catch (_) {}
+  try { require('./register') } catch (_) {}
+  try { require('./register-restify') } catch (_) {}
+}
+
+class AzifyLogger {
+  constructor(options = {}) {
+    this.options = {
+      serviceName: options.serviceName || 'azipay',
+      loggerUrl: options.loggerUrl || 'http://localhost:3000',
+      environment: options.environment || process.env.NODE_ENV || 'development',
+      ...options
+    }
+    
+    this.propagator = new W3CTraceContextPropagator()
+    propagation.setGlobalPropagator(this.propagator)
+  }
+
+  async log(level, message, meta = {}) {
+    const span = trace.getSpan(context.active())
+    const spanContext = span?.spanContext()
+    
+    const logData = {
+      level,
+      message,
+      meta: {
+        ...meta,
+        service: {
+          name: this.options.serviceName,
+          version: meta.service?.version || '1.0.0'
+        },
+        environment: this.options.environment,
+        timestamp: new Date().toISOString(),
+        hostname: require('os').hostname()
+      }
+    }
+
+    if (spanContext) {
+      logData.meta.traceId = spanContext.traceId
+      logData.meta.spanId = spanContext.spanId
+    }
+
+    try {
+      const headers = {}
+      try {
+        propagation.inject(context.active(), headers, {
+          set (carrier, key, value) {
+            carrier[key] = value
+          }
+        })
+      } catch (_) {}
+
+      await axios.post(`${this.options.loggerUrl}/log`, logData, {
+        timeout: 5000,
+        headers
+      })
+    } catch (error) {
+      console.error('Erro ao enviar log:', error.message)
+    }
+  }
+
+  info(message, meta = {}) {
+    return this.log('info', message, meta)
+  }
+
+  error(message, error = null, meta = {}) {
+    const logMeta = { ...meta }
+    if (error) {
+      logMeta.error = {
+        message: error.message,
+        stack: error.stack,
+        name: error.name
+      }
+    }
+    return this.log('error', message, logMeta)
+  }
+
+  warn(message, meta = {}) {
+    return this.log('warn', message, meta)
+  }
+
+  debug(message, meta = {}) {
+    return this.log('debug', message, meta)
+  }
+}
+
+function createAzifyLogger(options = {}) {
+  return new AzifyLogger(options)
+}
+
+function createAzifyLoggerFromEnv() {
+  return createAzifyLogger({
+    serviceName: process.env.APP_NAME || 'azipay',
+    loggerUrl: process.env.AZIFY_LOGGER_URL || 'http://localhost:3000',
+    environment: process.env.NODE_ENV || 'development'
+  })
+}
+
+module.exports = AzifyLogger
+module.exports.createAzifyLogger = createAzifyLogger
+module.exports.createAzifyLoggerFromEnv = createAzifyLoggerFromEnv
+module.exports.streams = {
+  createBunyanStream: require('./streams/bunyan'),
+  createPinoStream: require('./streams/pino')
+}
+module.exports.middleware = {
+  restify: require('./middleware-restify'),
+  express: require('./middleware-express')
+}

package/middleware-express.js

@@ -0,0 +1,277 @@
+const axios = require('axios')
+const { als, runWithRequestContext, startRequestContext, getRequestContext } = require('./store')
+
+function createExpressLoggingMiddleware(options = {}) {
+  const config = {
+    serviceName: options.serviceName || process.env.APP_NAME || 'assemble',
+    loggerUrl: options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3000',
+    environment: options.environment || process.env.NODE_ENV || 'development'
+  }
+
+  async function sendLog(level, message, meta = {}) {
+    const logData = {
+      level,
+      message,
+      meta: {
+        ...meta,
+        service: {
+          name: config.serviceName,
+          version: '1.0.0'
+        },
+        environment: config.environment,
+        timestamp: new Date().toISOString(),
+        hostname: require('os').hostname()
+      }
+    }
+
+    try {
+      await axios.post(`${config.loggerUrl}/log`, logData, {
+        timeout: 5000
+      })
+    } catch (error) {}
+  }
+
+  return function azifyExpressLoggingMiddleware(req, res, next) {
+    const startTime = Date.now()
+    const requestId = req.requestId || require('uuid').v4()
+    const middlewareId = require('uuid').v4().substring(0, 8)
+    
+    const reqCtx = startRequestContext({ requestId })
+    req.__azifyTraceId = reqCtx.traceId
+    req.__azifySpanId = reqCtx.spanId
+    req.__azifyParentSpanId = reqCtx.parentSpanId
+    
+    const requestTraceId = req.__azifyTraceId
+    const requestSpanId = req.__azifySpanId
+    const requestParentSpanId = req.__azifyParentSpanId
+    
+    let baseUrl = req.url
+    if (baseUrl.includes('?')) {
+      baseUrl = baseUrl.substring(0, baseUrl.indexOf('?'))
+    }
+    baseUrl = baseUrl.replace(/\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '/{id}')
+    baseUrl = baseUrl.replace(/\/[0-9]+/g, '/{id}')
+
+    req._azifyRequestData = {
+      requestId,
+      method: req.method,
+      url: req.url,
+      baseUrl: baseUrl,
+      path: req.url,
+      headers: req.headers,
+      query: req.query,
+      userAgent: req.headers['user-agent'],
+      ip: req.connection?.remoteAddress || req.socket?.remoteAddress || req.ip,
+      traceId: requestTraceId,
+      spanId: requestSpanId,
+      parentSpanId: requestParentSpanId
+    }
+
+    if (req.method === 'GET') {
+      sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
+    } else {
+      if (req.body !== undefined) {
+        req._azifyRequestData.requestBody = req.body
+      }
+      sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
+    }
+
+    res.on('finish', () => {
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+    })
+
+    res.on('close', () => {
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+    })
+
+    let sentBody
+    let responseLogged = false
+    
+    const originalSend = res.send && res.send.bind(res)
+    if (originalSend) {
+      res.send = function patchedSend() {
+        try {
+          if (arguments.length === 1) {
+            sentBody = arguments[0]
+          } else if (arguments.length >= 2) {
+            sentBody = typeof arguments[0] === 'number' ? arguments[1] : (arguments[1] || arguments[0])
+          }
+        } catch (_) {}
+        
+        if (!responseLogged) {
+          logResponse()
+          responseLogged = true
+        }
+        
+        return originalSend.apply(this, arguments)
+      }
+    }
+
+    const originalStatus = res.status
+    res.status = function(code) {
+      res._actualStatusCode = code
+      return originalStatus.call(this, code)
+    }
+    
+    const originalWriteHead = res.writeHead
+    res.writeHead = function(statusCode, statusMessage, headers) {
+      res._actualStatusCode = statusCode
+      if (typeof statusMessage === 'object') {
+        headers = statusMessage
+        statusMessage = undefined
+      }
+      return originalWriteHead.call(this, statusCode, statusMessage, headers)
+    }
+    
+    const originalJsonMethod = res.json
+    res.json = function(code, body) {
+      try {
+        if (arguments.length === 1) {
+          sentBody = arguments[0]
+        } else if (arguments.length >= 2) {
+          sentBody = typeof arguments[0] === 'number' ? arguments[1] : (arguments[1] || arguments[0])
+        }
+      } catch (_) {}
+      
+      if (typeof code === 'number') {
+        res._actualStatusCode = code
+      } else {
+        const errorObj = arguments.length === 1 ? arguments[0] : (typeof arguments[0] === 'number' ? arguments[1] : arguments[0])
+        
+        if (errorObj && errorObj.constructor && errorObj.constructor.name === 'ErrCtor') {
+          const errorName = errorObj.toString()
+          if (errorName.includes('InternalServerError') || errorName.includes('InternalError')) {
+            res._actualStatusCode = 500
+          } else if (errorName.includes('BadRequest') || errorName.includes('BadDigest')) {
+            res._actualStatusCode = 400
+          } else if (errorName.includes('NotFound')) {
+            res._actualStatusCode = 404
+          } else if (errorName.includes('Unauthorized')) {
+            res._actualStatusCode = 401
+          } else if (errorName.includes('Forbidden')) {
+            res._actualStatusCode = 403
+          } else {
+            res._actualStatusCode = 500
+          }
+        } else {
+          res._actualStatusCode = res.statusCode || 200
+        }
+      }
+      
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+      
+      return originalJsonMethod.apply(this, arguments)
+    }
+    
+    res.on('finish', function() {
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+    })
+
+    const originalEnd = res.end
+    res.end = function(chunk, encoding) {
+      const duration = Date.now() - startTime
+      
+      let responseBody = sentBody
+      try {
+        if (responseBody == null && chunk) {
+          if (Buffer.isBuffer(chunk)) {
+            responseBody = chunk.toString('utf8')
+          } else if (typeof chunk === 'string') {
+            responseBody = chunk
+          } else {
+            responseBody = JSON.stringify(chunk)
+          }
+        }
+      } catch (_) {}
+
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+
+      originalEnd.call(this, chunk, encoding)
+    }
+    
+    function logResponse() {
+      const duration = Date.now() - startTime
+      
+      let responseBody = sentBody
+      
+      let serializedResponseBody
+      try {
+        if (typeof responseBody === 'string') {
+          serializedResponseBody = responseBody
+        } else if (Array.isArray(responseBody)) {
+          serializedResponseBody = JSON.stringify(responseBody)
+        } else if (responseBody && typeof responseBody === 'object') {
+          if (responseBody.toJSON && typeof responseBody.toJSON === 'function') {
+            serializedResponseBody = JSON.stringify(responseBody.toJSON())
+          } else if (responseBody.toString && typeof responseBody.toString === 'function' && responseBody.toString() !== '[object Object]') {
+            serializedResponseBody = responseBody.toString()
+          } else {
+            serializedResponseBody = JSON.stringify(responseBody, (key, value) => {
+              if (typeof value === 'function') {
+                return '[Function]'
+              }
+              if (value instanceof Error) {
+                return { name: value.name, message: value.message, stack: value.stack }
+              }
+              return value
+            }, null, 0)
+          }
+        } else {
+          serializedResponseBody = responseBody != null ? String(responseBody) : ''
+        }
+      } catch (error) {
+        try {
+          serializedResponseBody = JSON.stringify(responseBody, null, 2)
+        } catch (secondError) {
+          serializedResponseBody = '[Complex object - serialization failed]'
+        }
+      }
+      
+      const statusCode = res._actualStatusCode || res._statusCode || res.statusCode || 200
+      
+      const responseMessage = serializedResponseBody && serializedResponseBody.length > 0
+        ? `[RESPONSE] ${serializedResponseBody}`
+        : `[RESPONSE] ${req.method} ${req.url} ${statusCode} ${duration}ms`
+      
+      const responseData = {
+        ...req._azifyRequestData,
+        requestBody: req.body,
+        statusCode: statusCode,
+        responseTime: duration,
+        responseHeaders: res.getHeaders ? res.getHeaders() : {},
+        responseBody: serializedResponseBody
+      }
+      
+      try { res._azifyResponseLogged = true } catch (_) {}
+      sendLog('info', responseMessage, responseData)
+    }
+
+    req._azifyContext = reqCtx
+    
+    try {
+      runWithRequestContext(reqCtx, () => {
+        next()
+      })
+    } catch (error) {
+      console.error('Error in azify middleware:', error)
+      next()
+    }
+  }
+}
+
+module.exports = createExpressLoggingMiddleware