azify-logger 1.0.24 → 1.0.26

package/README.md

@@ -6,36 +6,22 @@ Sistema de logging centralizado com OpenTelemetry e OpenSearch para múltiplas a
 
 ### URLs para configurar nas aplicações:
 
-| Ambiente | URL                                                   |
-|----------|-------------------------------------------------------|
-| **Development** | `http://localhost:3001/log`                           |
-| **Staging** | `https://logsdashboard.azify.dev/send`                |
-| **Production** | `https://logsdashboard.azify.prd/send` (a configurar) |
+| Ambiente | URL |
+|----------|-----|
+| **Development** | `http://localhost:3001/log` |
+| **Staging** | `https://logsdashboard.azify.dev/send` |
+| **Production** | `https://logsdashboard.azify.prd/send` | (a configurar)
 
+### URLs para acessar os logs:
 
-### URLs para acessar os logs e dashs:
-
-| Ambiente | URL                                              |
-|----------|--------------------------------------------------|
-| **Development** | `http://localhost:5601`                          |
-| **Staging** | `https://logsdashboard.azify.dev`                |
-| **Production** | `https://logsdashboard.azify.com` (a configurar) |
-
+| Ambiente | URL |
+|----------|-----|
+| **Development** | Grafana: `http://localhost:3002` |
+| **Staging** | `https://logsdashboard.azify.dev` |
+| **Production** | `https://logsdashboard.azify.com` |
 
 ## 📦 Instalação
 
-Na sua aplicação, adicione ao `package.json`:
-
-```json
-{
-  "dependencies": {
-    "azify-logger": "latest"
-  }
-}
-```
-
-Ou via npm:
-
 ```bash
 npm install azify-logger
 ```
@@ -44,91 +30,36 @@ npm install azify-logger
 
 ### Para aplicações Restify:
 
-**1. No arquivo de inicialização:**
 ```javascript
-#!/usr/bin/env node
+// 1. No arquivo de inicialização
 require('azify-logger/register-otel');
-// Resto do código...
-```
 
-**2. No servidor Restify:**
-```javascript
+// 2. No servidor
 import { middleware as azifyMiddleware } from 'azify-logger'
-
 const server = restify.createServer()
 server.use(azifyMiddleware.restify())
-```
 
-**3. Variável de ambiente:**
-```bash
+// 3. Variável de ambiente
 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:3001/log`       | URL do logger |
+| Variável | Padrão | Descrição |
+|----------|-------|-----------|
+| `APP_NAME` | - | Nome da aplicação |
+| `AZIFY_LOGGER_URL` | `http://localhost:3001/log` | URL do logger |
 | `NODE_ENV` | `development` | Ambiente |
 
-### 🌐 URLs por Ambiente
-
-**Desenvolvimento (Local):**
-```env
-APP_NAME=minha-app
-AZIFY_LOGGER_URL=http://localhost:3001/log
-NODE_ENV=development
-```
-
-**Staging:**
-```env
-APP_NAME=minha-app
-AZIFY_LOGGER_URL=https://logsdashboard.azify.dev/send
-NODE_ENV=staging
-```
-
-**Production:**
-```env
-APP_NAME=minha-app
-AZIFY_LOGGER_URL=https://logsdashboard.azify.prd/send (a conigurar)
-NODE_ENV=production
-```
-
-### 🐳 Docker Compose (mesma network)
-
-Apenas se estiver usando Docker Compose com rede compartilhada:
-
-```env
-AZIFY_LOGGER_URL=http://azify-logger:3001/log
-```
-
-### 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
@@ -137,89 +68,61 @@ Isso evita carregar `register-otel.js` e mantém os envios de log via streams/mi
 - ✅ **Genérico**: Funciona com Bunyan, Pino, console.log ou qualquer logger
 - ✅ **Centralizado**: Todos os logs no OpenSearch
 
-## 🔧 Uso Avançado
+## 🔍 Como Funciona
 
-### Com Bunyan existente (adicionar stream)
+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
 
-Se sua app **já tem Bunyan** e você quer adicionar o azify-logger como stream adicional:
+## 📖 Arquitetura
 
-```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:3001/log',
-      serviceName: process.env.APP_NAME || 'app'
-      loggerUrl: process.env.AZIFY_LOGGER_URL,
-      serviceName: process.env.APP_NAME
-    })
-  })
-}
-
-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
+┌─────────────┐
+│  aplicação  │  
+└──────┬──────┘
+       │ HTTP POST
+       ↓
+┌─────────────┐
+│ azify-logger│  (recebe logs)
+└──────┬──────┘
+       │
+       ↓
+┌─────────────┐
+│ OpenSearch  │  (armazena em logs-{appName})
+└──────┬──────┘
+       │
+       ↓
+┌─────────────┐
+│   Grafana   │  (visualiza - Organizations por app)
+└─────────────┘
 ```
 
-### Com Pino
-
-```javascript
-const { streams } = require('azify-logger')
-const pino = require('pino')
+## 📈 Grafana - Visualização de Logs
 
-const logger = pino({ level: 'info' }, streams.createPinoStream({
-  loggerUrl: 'http://localhost:3001/log',
-  serviceName: 'nome-app'
-}))
+O azify-logger usa Grafana para visualização dos logs com controle de acesso por aplicação.
 
-logger.info('Teste')
-```
+### Funcionalidades
 
-### Logger Direto (sem Bunyan/Pino)
+- **📊 Explore**: Busca e visualização de logs em tempo real
+- **📈 Dashboards**: Dashboards automáticos com métricas (Total de Requisições, Taxa de Sucesso, Erros, Tempo Médio de Resposta, etc.)
 
-```javascript
-const { createAzifyLogger } = require('azify-logger')
+### Controle de Acesso Automático
 
-const logger = createAzifyLogger({
-  serviceName: 'nome-app',
-  loggerUrl: 'http://localhost:3001/log'
-})
+Quando uma aplicação envia logs pela primeira vez, o sistema automaticamente:
 
-logger.info('Mensagem', { userId: '123' })
-logger.error('Erro', new Error('Falha'), { context: 'payment' })
-```
+1. ✅ Cria uma **Organization** no Grafana com o nome da aplicação
+2. ✅ Cria um **Datasource** filtrado para o índice `logs-{appName}`
+3. ✅ Cria um **Dashboard** completo com métricas
+4. ✅ Isola completamente os logs da aplicação
 
----
-
-## 🛠️ Setup do Serviço de Logging (Infra)
-
-Se você precisa subir a infraestrutura do azify-logger:
+**Gerenciar acesso:**
+- Acesse Grafana como Server Admin
+- Vá em **Administration** → **Organizations**
+- Adicione usuários à Organization da app
+- **⚠️ Importante**: Use role **Editor** ou **Admin** para acesso ao Explorer (onde estão os logs). Role **Viewer** não tem acesso ao Explorer.
 
+## 🛠️ Setup Local
 
 ```bash
 ./start-docker.sh
@@ -230,12 +133,22 @@ Aguarde alguns minutos. Você verá:
 ```
 ✅ Tudo pronto!
 📊 OpenSearch: http://localhost:9200
-🎨 OpenSearch Dashboards: http://localhost:5601
+📈 Grafana: http://localhost:3002
 📝 Logger API: http://localhost:3001/log
-🔭 OTEL Collector: http://localhost:4318
 ```
 
-### 2. Testar
+### Configuração de Ambiente
+
+Copie os arquivos de exemplo e preencha com seus valores:
+
+```bash
+cp env/app.env.example env/app.env
+cp env/grafana.env.example env/grafana.env
+```
+
+Edite `env/app.env` e `env/grafana.env` com suas configurações do Azure AD e outras variáveis.
+
+### Testar
 
 ```bash
 curl -X POST http://localhost:3001/log \
@@ -243,97 +156,30 @@ curl -X POST http://localhost:3001/log \
   -d '{
     "level": "info",
     "message": "Teste",
-    "meta": {"service": {"name": "teste"}}
+    "meta": {"service": {"name": "minha-app"}}
   }'
 ```
 
-### 3. Ver logs
+Acesse `http://localhost:3002` e faça login com Azure AD.
 
-**OpenSearch Dashboards:**
-```bash
-http://localhost:5601
-```
+## 🚀 Deploy
 
-**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
+### Staging - Deploy Automático
 
-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)
-└─────────────┘
+```bash
+git push origin master
 ```
 
-## 📈 OpenSearch Dashboards
+O deploy é feito automaticamente via GitHub Actions.
 
-O azify-logger usa OpenSearch Dashboards para visualização dos logs:
+### Production - Deploy Manual
 
-### 🎯 Funcionalidades Disponíveis
+1. Acesse: **GitHub** → **Actions** → **Deploy**
+2. Clique em **Run workflow**
+3. Configure: **Environment:** `production`
+4. Clique em **Run workflow**
 
-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
-
-### ⚠️ Preservação de Dados
+## ⚠️ Preservação de Dados
 
 **IMPORTANTE:** Logs do OpenSearch são armazenados em volume Docker persistente.
 
@@ -341,10 +187,9 @@ O azify-logger usa OpenSearch Dashboards para visualização dos logs:
 ```bash
 docker-compose stop
 docker-compose restart
-pm2 stop azify-logger
 ```
 
 **Comandos destrutivos** (APAGAM logs):
 ```bash
 docker-compose down -v  # ⚠️ APAGA VOLUMES!
-```
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -30,17 +30,39 @@
     "axios": "^1.6.0",
     "cors": "^2.8.5",
     "express": "^4.18.2",
+    "express-session": "^1.17.3",
+    "passport": "^0.6.0",
+    "passport-azure-ad": "^4.3.5",
+    "js-yaml": "^4.1.0",
     "require-in-the-middle": "^7.4.0",
     "uuid": "^9.0.1"
   },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.1.0 <1.6.0",
+    "@opentelemetry/core": ">=1.1.0 <1.6.0",
+    "@opentelemetry/resources": ">=1.1.0 <1.6.0",
+    "@opentelemetry/semantic-conventions": ">=1.1.0 <1.6.0",
+    "@opentelemetry/sdk-node": ">=0.39.1 <0.42.0",
+    "@opentelemetry/exporter-trace-otlp-http": ">=0.39.1 <0.42.0",
+    "@opentelemetry/auto-instrumentations-node": ">=0.39.1 <0.42.0"
+  },
   "optionalDependencies": {
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.40.0",
-    "@opentelemetry/core": "^1.28.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.45.0",
-    "@opentelemetry/resources": "^1.28.0",
-    "@opentelemetry/sdk-node": "^0.45.0",
-    "@opentelemetry/semantic-conventions": "^1.28.0"
+    "@opentelemetry/api": "1.1.0",
+    "@opentelemetry/core": "1.1.0",
+    "@opentelemetry/resources": "1.1.0",
+    "@opentelemetry/semantic-conventions": "1.1.0",
+    "@opentelemetry/sdk-node": "0.39.1",
+    "@opentelemetry/exporter-trace-otlp-http": "0.39.1",
+    "@opentelemetry/auto-instrumentations-node": "0.39.1"
+  },
+  "overrides": {
+    "@opentelemetry/api": "1.1.0",
+    "@opentelemetry/core": "1.1.0",
+    "@opentelemetry/resources": "1.1.0",
+    "@opentelemetry/semantic-conventions": "1.1.0",
+    "@opentelemetry/sdk-node": "0.39.1",
+    "@opentelemetry/exporter-trace-otlp-http": "0.39.1",
+    "@opentelemetry/auto-instrumentations-node": "0.39.1"
   },
   "engines": {
     "node": ">=12.0.0"

package/register.js

@@ -380,6 +380,155 @@ try {
     }
   } catch (_) {}
 
+  try {
+    if (typeof globalThis.fetch === 'function') {
+      const g = globalThis
+      if (!g.__azifyLoggerFetchPatched) {
+        g.__azifyLoggerFetchPatched = true
+
+        const { getRequestContext, runWithRequestContext } = require('./store')
+        const { randomUUID, randomBytes } = require('crypto')
+        const { performance } = require('perf_hooks')
+        const axios = require('axios')
+        const os = require('os')
+
+        const serviceName = process.env.APP_NAME || 'app'
+        const loggerUrl = process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log'
+        const environment = process.env.NODE_ENV || 'development'
+
+        async function sendLog(level, message, meta) {
+          const payload = {
+            level,
+            message,
+            meta: {
+              ...meta,
+              service: {
+                name: serviceName,
+                version: (meta && meta.service && meta.service.version) || '1.0.0'
+              },
+              environment,
+              timestamp: new Date().toISOString(),
+              hostname: os.hostname()
+            }
+          }
+
+          try {
+            await axios.post(loggerUrl, payload, { timeout: 5000 })
+          } catch (error) {
+            console.error('Erro ao enviar log:', error && error.message ? error.message : error)
+          }
+        }
+
+        const originalFetch = globalThis.fetch.bind(globalThis)
+
+        function sanitizeHeaders(headers) {
+          const SENSITIVE_HEADER_KEYS = new Set([
+            'authorization',
+            'cookie',
+            'set-cookie',
+            'x-api-key',
+            'x-auth-token',
+            'x-access-token',
+            'proxy-authorization'
+          ])
+
+          const sanitized = {}
+          headers.forEach((value, key) => {
+            const lower = key.toLowerCase()
+            if (SENSITIVE_HEADER_KEYS.has(lower)) {
+              sanitized[lower] = '***'
+            } else {
+              sanitized[lower] = value
+            }
+          })
+          return sanitized
+        }
+
+        function ensureRequest(input, init) {
+          if (typeof Request !== 'undefined' && input instanceof Request) {
+            return init ? new Request(input, init) : input
+          }
+          return new Request(input, init)
+        }
+
+        globalThis.fetch = async function patchedFetch(input, init) {
+          const request = ensureRequest(input, init)
+          const method = request.method.toUpperCase()
+          const url = request.url
+
+          const ctx = getRequestContext()
+          const traceId = (ctx && ctx.traceId) || randomUUID()
+          const parentSpanId = (ctx && ctx.spanId) || null
+          const requestId = (ctx && 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,
+            parentSpanId,
+            requestId,
+            method,
+            url,
+            headers: sanitizeHeaders(request.headers)
+          }
+
+          const start = performance.now()
+          void sendLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+
+          const childCtx = {
+            traceId,
+            spanId,
+            parentSpanId,
+            requestId
+          }
+
+          try {
+            const response = await runWithRequestContext(childCtx, function() {
+              return originalFetch(request)
+            })
+
+            const duration = Number((performance.now() - start).toFixed(2))
+            const responseMeta = {
+              ...requestMeta,
+              statusCode: response.status,
+              responseTimeMs: duration
+            }
+
+            const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
+            if (response.status >= 500) {
+              void sendLog('error', message, responseMeta)
+            } else if (response.status >= 400) {
+              void sendLog('warn', message, responseMeta)
+            } else {
+              void sendLog('info', message, responseMeta)
+            }
+
+            return response
+          } catch (error) {
+            const duration = Number((performance.now() - start).toFixed(2))
+            const errorMeta = {
+              ...requestMeta,
+              responseTimeMs: duration
+            }
+            const err = error instanceof Error ? error : new Error(String(error))
+            errorMeta.error = {
+              name: err.name,
+              message: err.message,
+              stack: err.stack
+            }
+            void sendLog('error', `[ERROR] ${method} ${url}`, errorMeta)
+            throw error
+          }
+        }
+      }
+    }
+  } catch (_) {}
+
   try {
     const Bull = require('bull')
     const { runWithRequestContext } = require('./store')