@mecanizou/telemetry-hub 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,248 @@
+# 📊 Telemetry Hub
+
+Biblioteca centralizada para telemetria e logging estruturado padronizado, compatível com múltiplos frameworks (Tsed, SST/Middy).
+
+## 🔗 Quick Links
+
+- **📘 Guias por Framework:**
+  - [Tsed](./src/telemetry/tsed/README.md)
+  - [SST/Middy](./src/telemetry/sst/README.md)
+- **📖 Conceitos Core:**
+  - [Logging Padronizado](./src/telemetry/core/LOGGING.md)
+  - [Tracing Padronizado](./src/telemetry/core/TRACING.md)
+  - [Testes](./src/telemetry/core/__tests__/README.md)
+
+## 🎯 Objetivo
+
+Padronizar a forma como logs são gerados em diferentes tipos de projetos, garantindo:
+- **Consistência** nos campos de log entre diferentes implementações
+- **Observabilidade** através do OpenTelemetry
+- **Facilidade de manutenção** com uma única fonte de verdade
+
+## 📦 Instalação
+
+```bash
+npm install @mecanizou/telemetry-hub
+```
+
+## 🏗️ Arquitetura
+
+```
+src/telemetry/
+├── core/                    # 🎯 Implementação base (StandardLogger, StandardTracer)
+│   ├── types.ts             # Interface StandardLogData
+│   ├── logger.ts            # StandardLogger
+│   ├── tracer-types.ts      # Interface StandardTraceData
+│   ├── tracer.ts            # StandardTracer
+│   ├── index.ts             # Exports
+│   ├── README.md            # 📚 Visão geral do Core
+│   ├── LOGGING.md           # 📝 Guia de logging
+│   ├── TRACING.md           # 🔍 Guia de tracing
+│   └── __tests__/           # Testes (57 testes, 100% cobertura)
+│       ├── logger.test.ts
+│       ├── tracer.test.ts
+│       ├── logger-types.test.ts
+│       └── README.md        # 📚 Documentação dos testes
+│
+├── tsed/                    # 🔷 Implementação para Tsed
+│   ├── config.ts            # TsedTelemetryProvider (logs + traces + métricas)
+│   ├── service.ts           # TsedTelemetryService
+│   ├── log-telemetry.ts     # Decorator @TsedLogTelemetry
+│   ├── sync-log-record-processor.ts
+│   ├── index.ts
+│   ├── README.md            # 📚 Guia de uso Tsed
+│   ├── IMPLEMENTATION_SUMMARY.md    # 📝 Resumo da implementação
+│   └── SST_COMPARISON.md    # 🔄 Comparação Tsed vs SST
+│
+└── sst/                     # 🟦 Implementação para SST/Middy
+    ├── telemetry.ts         # Configuração OpenTelemetry + getStandardLogger/Tracer
+    ├── index.ts
+    ├── README.md            # 📚 Guia de uso SST
+    └── middy/
+        ├── middleware.ts    # Middleware Middy (usa StandardLogger + StandardTracer)
+        └── index.ts
+```
+
+### Componentes Principais
+
+#### 1. **StandardLogger** (Core)
+- Classe base que formata logs no padrão OpenTelemetry
+- Garante que todos os campos seguem a mesma estrutura
+- Implementa os métodos: `logError`, `logInfo`, `logWarn`, `logDebug`
+
+#### 2. **StandardLogData** (Interface)
+Define o contrato padrão de log com campos:
+- **severity**, **message**, **error**
+- **serviceName**, **environment**
+- **http** (method, url, endpoint, statusCode, etc.)
+- **user** (accountUserUid, accountUid, applicationUid)
+- **execution** (requestId, awsRequestId, functionName, controller, etc.)
+- **performance** (durationMs, success)
+- **context** (dados adicionais)
+
+## 🚀 Uso
+
+### Para Projetos Tsed
+
+```typescript
+import { 
+  TsedTelemetryProvider, 
+  TsedTelemetryService,
+  TsedLogTelemetry 
+} from '@mecanizou/telemetry-hub';
+
+// 1. Configurar provider (no módulo principal)
+@Configuration({
+  // ...
+})
+export class Server {
+  @Inject()
+  protected telemetryProvider: TsedTelemetryProvider;
+
+  async $afterInit() {
+    await this.telemetryProvider.initialize();
+  }
+}
+
+// 2. Usar decorator nos controllers
+export class CheckoutController {
+  @TsedLogTelemetry()
+  async getCheckout(@Context() $ctx: ServerlessContext) {
+    // Erros são capturados e logados automaticamente
+    return await this.service.execute();
+  }
+}
+```
+
+### Para Projetos SST (Lambdas com Middy)
+
+```typescript
+import { middyMiddleware } from '@mecanizou/telemetry-hub';
+import middy from '@middy/core';
+
+export const handler = middy(async (event, context) => {
+  // Sua lógica aqui
+  return { statusCode: 200, body: 'OK' };
+}).use(middyMiddleware());
+```
+
+O middleware automaticamente:
+- Registra logs de INFO em caso de sucesso
+- Registra logs de ERROR em caso de falha
+- Mantém traces e métricas do OpenTelemetry
+
+## ⚙️ Configuração
+
+### Variáveis de Ambiente Obrigatórias
+
+```bash
+OTEL_EXPORTER_OTLP_ENDPOINT=https://seu-endpoint-otel.com
+OTEL_EXPORTER_OTLP_USER=seu-usuario
+OTEL_EXPORTER_OTLP_PASS=sua-senha
+```
+
+### Variáveis de Ambiente Opcionais
+
+```bash
+SERVICE_NAME=my-service        # Default: 'unknown-service' (Tsed) ou 'sst-service' (SST)
+STAGE=production               # Default: 'development'
+```
+
+## ✅ Testes
+
+O projeto possui **79 testes** com 100% de cobertura:
+
+- **Core**: 57 testes (logger, tracer, tipos)
+- **SST**: 9 testes (integração, singleton, forceFlush)
+- **Tsed**: 13 testes (provider, service, integração)
+
+Para executar:
+```bash
+npm test              # Executar todos os testes
+npm run test:watch    # Modo watch
+npm run test:ui       # UI interativa
+npm run test:coverage # Relatório de cobertura
+```
+
+## 📝 Campos Padronizados de Log
+
+Todos os logs exportam os seguintes atributos OpenTelemetry:
+
+```typescript
+{
+  // Identificação
+  timestamp: "2024-12-05T10:30:00.000Z",
+  "service.name": "cart-service",
+  "deployment.environment.name": "production",
+  
+  // Erro (quando aplicável)
+  "error.type": "ValidationError",
+  "error.message": "Invalid cart item",
+  "error.stack": "...",
+  
+  // HTTP
+  "http.method": "POST",
+  "http.url": "/api/cart/checkout",
+  "http.endpoint": "/api/cart/checkout",
+  "http.status_code": 400,
+  
+  // Usuário
+  "accountUser.uid": "user-123",
+  "account.uid": "account-456",
+  "application.uid": "app-789",
+  
+  // Execução
+  "request.id": "req-abc",
+  "aws.request.id": "aws-xyz",
+  "faas.name": "checkoutHandler",
+  "faas.invocation_id": "inv-123",
+  "controller.name": "CheckoutController",
+  "controller.method": "getCheckout",
+  "origin": "mobile",
+  
+  // Performance
+  "duration.ms": 234,
+  "execution.success": true,
+  
+  // Contexto adicional
+  "context": "{...}"
+}
+```
+
+## 🔄 Compatibilidade
+
+| Framework | Versão Testada | Status |
+|-----------|---------------|--------|
+| Tsed      | ^8.19.4       | ✅     |
+| SST/Middy | ^6.4.5        | ✅     |
+| OpenTelemetry | ^0.56.0 | ✅     |
+
+## 📚 Documentação Adicional
+
+> 📖 **[Guia de Navegação da Documentação](./DOCS_GUIDE.md)** - Mapa completo de toda documentação disponível
+
+### Core (Conceitos e Implementação Base)
+- [Core README](./src/telemetry/core/README.md) - Visão geral do StandardLogger e StandardTracer
+- [LOGGING.md](./src/telemetry/core/LOGGING.md) - Guia detalhado de logging estruturado
+- [TRACING.md](./src/telemetry/core/TRACING.md) - Guia detalhado de traces padronizados
+- [Testes](./src/telemetry/core/__tests__/README.md) - Documentação dos testes (57 tests, 100% coverage)
+
+### Por Framework
+- **Tsed:** [src/telemetry/tsed/README.md](./src/telemetry/tsed/README.md)
+  - [Resumo da Implementação](./src/telemetry/tsed/IMPLEMENTATION_SUMMARY.md)
+  - [Comparação Tsed vs SST](./src/telemetry/tsed/SST_COMPARISON.md)
+- **SST:** [src/telemetry/sst/README.md](./src/telemetry/sst/README.md)
+
+## 🤝 Contribuindo
+
+Esta é uma lib interna da Mecanizou. Para contribuir:
+
+1. Clone o repositório
+2. Instale dependências: `npm install`
+3. Execute testes: `npm test`
+4. Execute verificação de tipo: `npm run test:tsc`
+5. Formate código: `npm run fix`
+
+## 📄 Licença
+
+ISC

package/dist/check-if-is-working.js

@@ -5,4 +5,4 @@ function checkIfIsWorking() {
     console.log('I am working');
     return 'I am working';
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2staWYtaXMtd29ya2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jaGVjay1pZi1pcy13b3JraW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsNENBR0M7QUFIRCxTQUFnQixnQkFBZ0I7SUFDOUIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUM1QixPQUFPLGNBQWMsQ0FBQztBQUN4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGNoZWNrSWZJc1dvcmtpbmcoKSB7XG4gIGNvbnNvbGUubG9nKCdJIGFtIHdvcmtpbmcnKTtcbiAgcmV0dXJuICdJIGFtIHdvcmtpbmcnO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2staWYtaXMtd29ya2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jaGVjay1pZi1pcy13b3JraW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsNENBR0M7QUFIRCxTQUFnQixnQkFBZ0I7SUFDOUIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUM1QixPQUFPLGNBQWMsQ0FBQztBQUN4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGNoZWNrSWZJc1dvcmtpbmcoKSB7XHJcbiAgY29uc29sZS5sb2coJ0kgYW0gd29ya2luZycpO1xyXG4gIHJldHVybiAnSSBhbSB3b3JraW5nJztcclxufVxyXG4iXX0=

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export { StandardLogger } from './logger';
+export { IStandardLogger, StandardLogData } from './types';

package/dist/core/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardLogger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "StandardLogger", { enumerable: true, get: function () { return logger_1.StandardLogger; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVsZW1ldHJ5L2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQTBDO0FBQWpDLHdHQUFBLGNBQWMsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFN0YW5kYXJkTG9nZ2VyIH0gZnJvbSAnLi9sb2dnZXInO1xyXG5leHBvcnQgeyBJU3RhbmRhcmRMb2dnZXIsIFN0YW5kYXJkTG9nRGF0YSB9IGZyb20gJy4vdHlwZXMnO1xyXG4iXX0=

package/dist/core/logger.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from '@opentelemetry/api-logs';
+import { IStandardLogger, StandardLogData } from './types';
+export declare class StandardLogger implements IStandardLogger {
+    private readonly defaultServiceName;
+    private logger;
+    constructor(logger: Logger, defaultServiceName?: string);
+    logError(data: Omit<StandardLogData, 'severity' | 'timestamp'>): Promise<void>;
+    logInfo(data: Omit<StandardLogData, 'severity' | 'timestamp'>): Promise<void>;
+    logWarn(data: Omit<StandardLogData, 'severity' | 'timestamp'>): Promise<void>;
+    logDebug(data: Omit<StandardLogData, 'severity' | 'timestamp'>): Promise<void>;
+    private log;
+    private buildAttributes;
+}

package/dist/core/logger.js

@@ -0,0 +1,123 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardLogger = void 0;
+const api_logs_1 = require("@opentelemetry/api-logs");
+class StandardLogger {
+    constructor(logger, defaultServiceName = 'unknown-service') {
+        this.defaultServiceName = defaultServiceName;
+        this.logger = logger;
+    }
+    logError(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.log(Object.assign(Object.assign({}, data), { severity: 'ERROR' }));
+        });
+    }
+    logInfo(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.log(Object.assign(Object.assign({}, data), { severity: 'INFO' }));
+        });
+    }
+    logWarn(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.log(Object.assign(Object.assign({}, data), { severity: 'WARN' }));
+        });
+    }
+    logDebug(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.log(Object.assign(Object.assign({}, data), { severity: 'DEBUG' }));
+        });
+    }
+    log(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullData = Object.assign(Object.assign({}, data), { timestamp: new Date().toISOString(), serviceName: data.serviceName || this.defaultServiceName });
+            const severityMap = {
+                ERROR: api_logs_1.SeverityNumber.ERROR,
+                WARN: api_logs_1.SeverityNumber.WARN,
+                INFO: api_logs_1.SeverityNumber.INFO,
+                DEBUG: api_logs_1.SeverityNumber.DEBUG,
+            };
+            const logRecord = {
+                severityNumber: severityMap[fullData.severity],
+                severityText: fullData.severity,
+                body: fullData.message,
+                attributes: this.buildAttributes(fullData),
+            };
+            this.logger.emit(logRecord);
+        });
+    }
+    buildAttributes(data) {
+        const attributes = {
+            timestamp: data.timestamp,
+            'service.name': data.serviceName,
+            'deployment.environment.name': data.environment,
+        };
+        if (data.error) {
+            attributes['error.type'] = data.error.name;
+            attributes['error.message'] = data.error.message;
+            attributes['error.stack'] = data.error.stack || '';
+        }
+        if (data.http) {
+            if (data.http.method)
+                attributes['http.method'] = data.http.method;
+            if (data.http.url)
+                attributes['http.url'] = data.http.url;
+            if (data.http.endpoint)
+                attributes['http.endpoint'] = data.http.endpoint;
+            if (data.http.statusCode)
+                attributes['http.status_code'] = data.http.statusCode;
+            if (data.http.headers)
+                attributes['http.headers'] = JSON.stringify(data.http.headers);
+            if (data.http.body)
+                attributes['http.body'] = JSON.stringify(data.http.body);
+            if (data.http.params)
+                attributes['http.params'] = JSON.stringify(data.http.params);
+            if (data.http.query)
+                attributes['http.query'] = JSON.stringify(data.http.query);
+        }
+        if (data.user) {
+            if (data.user.accountUserUid)
+                attributes['accountUser.uid'] = data.user.accountUserUid;
+            if (data.user.accountUid)
+                attributes['account.uid'] = data.user.accountUid;
+            if (data.user.applicationUid)
+                attributes['application.uid'] = data.user.applicationUid;
+        }
+        if (data.execution) {
+            if (data.execution.requestId)
+                attributes['request.id'] = data.execution.requestId;
+            if (data.execution.awsRequestId)
+                attributes['aws.request.id'] = data.execution.awsRequestId;
+            if (data.execution.functionName)
+                attributes['faas.name'] = data.execution.functionName;
+            if (data.execution.invocationId)
+                attributes['faas.invocation_id'] = data.execution.invocationId;
+            if (data.execution.controller)
+                attributes['controller.name'] = data.execution.controller;
+            if (data.execution.controllerMethod)
+                attributes['controller.method'] = data.execution.controllerMethod;
+            if (data.execution.origin)
+                attributes['origin'] = data.execution.origin;
+        }
+        if (data.performance) {
+            if (data.performance.durationMs)
+                attributes['duration.ms'] = data.performance.durationMs;
+            if (data.performance.success !== undefined)
+                attributes['execution.success'] = data.performance.success;
+        }
+        if (data.context) {
+            attributes['context'] = JSON.stringify(data.context);
+        }
+        return Object.fromEntries(Object.entries(attributes).filter(([, value]) => value !== undefined && value !== null));
+    }
+}
+exports.StandardLogger = StandardLogger;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/telemetry/core/logger.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,sDAAiE;AAOjE,MAAa,cAAc;IAGzB,YACE,MAAc,EACG,qBAA6B,iBAAiB;QAA9C,uBAAkB,GAAlB,kBAAkB,CAA4B;QAE/D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAEK,QAAQ,CACZ,IAAqD;;YAErD,MAAM,IAAI,CAAC,GAAG,iCAAM,IAAI,KAAE,QAAQ,EAAE,OAAO,IAAG,CAAC;QACjD,CAAC;KAAA;IAEK,OAAO,CACX,IAAqD;;YAErD,MAAM,IAAI,CAAC,GAAG,iCAAM,IAAI,KAAE,QAAQ,EAAE,MAAM,IAAG,CAAC;QAChD,CAAC;KAAA;IAEK,OAAO,CACX,IAAqD;;YAErD,MAAM,IAAI,CAAC,GAAG,iCAAM,IAAI,KAAE,QAAQ,EAAE,MAAM,IAAG,CAAC;QAChD,CAAC;KAAA;IAEK,QAAQ,CACZ,IAAqD;;YAErD,MAAM,IAAI,CAAC,GAAG,iCAAM,IAAI,KAAE,QAAQ,EAAE,OAAO,IAAG,CAAC;QACjD,CAAC;KAAA;IAEa,GAAG,CACf,IAEC;;YAED,MAAM,QAAQ,mCACT,IAAI,KACP,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EACnC,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,kBAAkB,GACzD,CAAC;YAEF,MAAM,WAAW,GAAG;gBAClB,KAAK,EAAE,yBAAc,CAAC,KAAK;gBAC3B,IAAI,EAAE,yBAAc,CAAC,IAAI;gBACzB,IAAI,EAAE,yBAAc,CAAC,IAAI;gBACzB,KAAK,EAAE,yBAAc,CAAC,KAAK;aAC5B,CAAC;YAEF,MAAM,SAAS,GAAG;gBAChB,cAAc,EAAE,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBAC9C,YAAY,EAAE,QAAQ,CAAC,QAAQ;gBAC/B,IAAI,EAAE,QAAQ,CAAC,OAAO;gBACtB,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC;aAC3C,CAAC;YAEF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC9B,CAAC;KAAA;IAEO,eAAe,CAAC,IAAqB;QAC3C,MAAM,UAAU,GAAwB;YACtC,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,cAAc,EAAE,IAAI,CAAC,WAAW;YAChC,6BAA6B,EAAE,IAAI,CAAC,WAAW;SAChD,CAAC;QAGF,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,UAAU,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YAC3C,UAAU,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YACjD,UAAU,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC;QACrD,CAAC;QAGD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM;gBAAE,UAAU,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;YACnE,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG;gBAAE,UAAU,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;YAC1D,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ;gBAAE,UAAU,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;YACzE,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU;gBACtB,UAAU,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC;YACxD,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO;gBACnB,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACjE,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI;gBAChB,UAAU,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3D,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM;gBAClB,UAAU,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC/D,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK;gBACjB,UAAU,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/D,CAAC;QAGD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc;gBAC1B,UAAU,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC;YAC3D,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU;gBACtB,UAAU,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC;YACnD,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc;gBAC1B,UAAU,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC;QAC7D,CAAC;QAGD,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS;gBAC1B,UAAU,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;YACtD,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY;gBAC7B,UAAU,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;YAC7D,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY;gBAC7B,UAAU,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;YACxD,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY;gBAC7B,UAAU,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;YACjE,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU;gBAC3B,UAAU,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;YAC5D,IAAI,IAAI,CAAC,SAAS,CAAC,gBAAgB;gBACjC,UAAU,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC;YACpE,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM;gBAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;QAC1E,CAAC;QAGD,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,IAAI,IAAI,CAAC,WAAW,CAAC,UAAU;gBAC7B,UAAU,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC;YAC1D,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,KAAK,SAAS;gBACxC,UAAU,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;QAC/D,CAAC;QAGD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,UAAU,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvD,CAAC;QAGD,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,MAAM,CAC/B,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,CACrD,CACF,CAAC;IACJ,CAAC;CACF;AA5ID,wCA4IC","sourcesContent":["import { SeverityNumber, Logger } from '@opentelemetry/api-logs';\r\nimport { IStandardLogger, StandardLogData } from './types';\r\n\r\n/**\r\n * Logger core que implementa o padrão de logs estruturados.\r\n * Recebe um LoggerProvider do OpenTelemetry para emitir os logs.\r\n */\r\nexport class StandardLogger implements IStandardLogger {\r\n  private logger: Logger;\r\n\r\n  constructor(\r\n    logger: Logger,\r\n    private readonly defaultServiceName: string = 'unknown-service'\r\n  ) {\r\n    this.logger = logger;\r\n  }\r\n\r\n  async logError(\r\n    data: Omit<StandardLogData, 'severity' | 'timestamp'>\r\n  ): Promise<void> {\r\n    await this.log({ ...data, severity: 'ERROR' });\r\n  }\r\n\r\n  async logInfo(\r\n    data: Omit<StandardLogData, 'severity' | 'timestamp'>\r\n  ): Promise<void> {\r\n    await this.log({ ...data, severity: 'INFO' });\r\n  }\r\n\r\n  async logWarn(\r\n    data: Omit<StandardLogData, 'severity' | 'timestamp'>\r\n  ): Promise<void> {\r\n    await this.log({ ...data, severity: 'WARN' });\r\n  }\r\n\r\n  async logDebug(\r\n    data: Omit<StandardLogData, 'severity' | 'timestamp'>\r\n  ): Promise<void> {\r\n    await this.log({ ...data, severity: 'DEBUG' });\r\n  }\r\n\r\n  private async log(\r\n    data: Omit<StandardLogData, 'timestamp'> & {\r\n      severity: StandardLogData['severity'];\r\n    }\r\n  ): Promise<void> {\r\n    const fullData: StandardLogData = {\r\n      ...data,\r\n      timestamp: new Date().toISOString(),\r\n      serviceName: data.serviceName || this.defaultServiceName,\r\n    };\r\n\r\n    const severityMap = {\r\n      ERROR: SeverityNumber.ERROR,\r\n      WARN: SeverityNumber.WARN,\r\n      INFO: SeverityNumber.INFO,\r\n      DEBUG: SeverityNumber.DEBUG,\r\n    };\r\n\r\n    const logRecord = {\r\n      severityNumber: severityMap[fullData.severity],\r\n      severityText: fullData.severity,\r\n      body: fullData.message,\r\n      attributes: this.buildAttributes(fullData),\r\n    };\r\n\r\n    this.logger.emit(logRecord);\r\n  }\r\n\r\n  private buildAttributes(data: StandardLogData): Record<string, any> {\r\n    const attributes: Record<string, any> = {\r\n      timestamp: data.timestamp,\r\n      'service.name': data.serviceName,\r\n      'deployment.environment.name': data.environment,\r\n    };\r\n\r\n    // Informações do erro\r\n    if (data.error) {\r\n      attributes['error.type'] = data.error.name;\r\n      attributes['error.message'] = data.error.message;\r\n      attributes['error.stack'] = data.error.stack || '';\r\n    }\r\n\r\n    // HTTP\r\n    if (data.http) {\r\n      if (data.http.method) attributes['http.method'] = data.http.method;\r\n      if (data.http.url) attributes['http.url'] = data.http.url;\r\n      if (data.http.endpoint) attributes['http.endpoint'] = data.http.endpoint;\r\n      if (data.http.statusCode)\r\n        attributes['http.status_code'] = data.http.statusCode;\r\n      if (data.http.headers)\r\n        attributes['http.headers'] = JSON.stringify(data.http.headers);\r\n      if (data.http.body)\r\n        attributes['http.body'] = JSON.stringify(data.http.body);\r\n      if (data.http.params)\r\n        attributes['http.params'] = JSON.stringify(data.http.params);\r\n      if (data.http.query)\r\n        attributes['http.query'] = JSON.stringify(data.http.query);\r\n    }\r\n\r\n    // Usuário\r\n    if (data.user) {\r\n      if (data.user.accountUserUid)\r\n        attributes['accountUser.uid'] = data.user.accountUserUid;\r\n      if (data.user.accountUid)\r\n        attributes['account.uid'] = data.user.accountUid;\r\n      if (data.user.applicationUid)\r\n        attributes['application.uid'] = data.user.applicationUid;\r\n    }\r\n\r\n    // Execução\r\n    if (data.execution) {\r\n      if (data.execution.requestId)\r\n        attributes['request.id'] = data.execution.requestId;\r\n      if (data.execution.awsRequestId)\r\n        attributes['aws.request.id'] = data.execution.awsRequestId;\r\n      if (data.execution.functionName)\r\n        attributes['faas.name'] = data.execution.functionName;\r\n      if (data.execution.invocationId)\r\n        attributes['faas.invocation_id'] = data.execution.invocationId;\r\n      if (data.execution.controller)\r\n        attributes['controller.name'] = data.execution.controller;\r\n      if (data.execution.controllerMethod)\r\n        attributes['controller.method'] = data.execution.controllerMethod;\r\n      if (data.execution.origin) attributes['origin'] = data.execution.origin;\r\n    }\r\n\r\n    // Performance\r\n    if (data.performance) {\r\n      if (data.performance.durationMs)\r\n        attributes['duration.ms'] = data.performance.durationMs;\r\n      if (data.performance.success !== undefined)\r\n        attributes['execution.success'] = data.performance.success;\r\n    }\r\n\r\n    // Contexto adicional\r\n    if (data.context) {\r\n      attributes['context'] = JSON.stringify(data.context);\r\n    }\r\n\r\n    // Filtrar valores undefined/null\r\n    return Object.fromEntries(\r\n      Object.entries(attributes).filter(\r\n        ([, value]) => value !== undefined && value !== null\r\n      )\r\n    );\r\n  }\r\n}\r\n"]}

package/dist/core/types.d.ts

@@ -0,0 +1,43 @@
+export interface StandardLogData {
+    severity: 'ERROR' | 'WARN' | 'INFO' | 'DEBUG';
+    message: string;
+    error?: Error;
+    serviceName: string;
+    environment: string;
+    http?: {
+        method?: string;
+        url?: string;
+        endpoint?: string;
+        statusCode?: number;
+        headers?: Record<string, any>;
+        body?: any;
+        params?: Record<string, any>;
+        query?: Record<string, any>;
+    };
+    user?: {
+        accountUserUid?: string;
+        accountUid?: string;
+        applicationUid?: string;
+    };
+    execution?: {
+        requestId?: string;
+        awsRequestId?: string;
+        functionName?: string;
+        invocationId?: string;
+        controller?: string;
+        controllerMethod?: string;
+        origin?: string;
+    };
+    performance?: {
+        durationMs?: number;
+        success?: boolean;
+    };
+    context?: Record<string, any>;
+    timestamp: string;
+}
+export interface IStandardLogger {
+    logError(data: Omit<StandardLogData, 'severity' | 'timestamp'>): Promise<void>;
+    logInfo(data: Omit<StandardLogData, 'severity' | 'timestamp'>): Promise<void>;
+    logWarn(data: Omit<StandardLogData, 'severity' | 'timestamp'>): Promise<void>;
+    logDebug(data: Omit<StandardLogData, 'severity' | 'timestamp'>): Promise<void>;
+}

package/dist/core/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -1 +1 @@
-export * from './check-if-is-working';
+export * from './telemetry';

package/dist/index.js

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./check-if-is-working"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdEQUFzQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2hlY2staWYtaXMtd29ya2luZyc7XG4iXX0=
+__exportStar(require("./telemetry"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhDQUE0QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGVsZW1ldHJ5JztcclxuIl19

package/dist/services/index.d.ts

@@ -0,0 +1 @@
+export * from './telemetry';

package/dist/services/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./telemetry"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhDQUE0QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGVsZW1ldHJ5JztcclxuIl19

package/dist/services/telemetry/config.d.ts

@@ -0,0 +1,20 @@
+import { LoggerProvider } from '@opentelemetry/sdk-logs';
+export interface TelemetryConfig {
+    endpoint: string;
+    username: string;
+    password: string;
+    serviceName?: string;
+    serviceVersion?: string;
+    enabled?: boolean;
+}
+export declare class TelemetryProvider {
+    private loggerProvider;
+    private initialized;
+    constructor();
+    initialize(config: TelemetryConfig): void;
+    getLoggerProvider(): LoggerProvider | null;
+    isInitialized(): boolean;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+    $onDestroy(): Promise<void>;
+}