@mecanizou/telemetry-hub 1.0.1 → 1.0.2

package/dist/core/__tests__/logger.test.js

@@ -0,0 +1,337 @@
+"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 });
+const vitest_1 = require("vitest");
+const logger_1 = require("../logger");
+const api_logs_1 = require("@opentelemetry/api-logs");
+(0, vitest_1.describe)('StandardLogger', () => {
+    let mockLogger;
+    let standardLogger;
+    (0, vitest_1.beforeEach)(() => {
+        mockLogger = {
+            emit: vitest_1.vi.fn(),
+        };
+        standardLogger = new logger_1.StandardLogger(mockLogger, 'test-service');
+    });
+    (0, vitest_1.describe)('logError', () => {
+        (0, vitest_1.it)('deve emitir log com severity ERROR', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorData = {
+                message: 'Test error message',
+                serviceName: 'test-service',
+                environment: 'test',
+            };
+            yield standardLogger.logError(errorData);
+            (0, vitest_1.expect)(mockLogger.emit).toHaveBeenCalledTimes(1);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.severityNumber).toBe(api_logs_1.SeverityNumber.ERROR);
+            (0, vitest_1.expect)(emittedLog.severityText).toBe('ERROR');
+            (0, vitest_1.expect)(emittedLog.body).toBe('Test error message');
+        }));
+        (0, vitest_1.it)('deve incluir informações do erro quando fornecido', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Custom error');
+            const errorData = {
+                message: 'Error occurred',
+                error,
+                serviceName: 'test-service',
+                environment: 'production',
+            };
+            yield standardLogger.logError(errorData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['error.type']).toBe('Error');
+            (0, vitest_1.expect)(emittedLog.attributes['error.message']).toBe('Custom error');
+            (0, vitest_1.expect)(emittedLog.attributes['error.stack']).toBeDefined();
+        }));
+        (0, vitest_1.it)('deve incluir contexto HTTP quando fornecido', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorData = {
+                message: 'HTTP error',
+                serviceName: 'test-service',
+                environment: 'production',
+                http: {
+                    method: 'POST',
+                    url: '/api/test',
+                    endpoint: '/api/test',
+                    statusCode: 500,
+                    headers: { 'content-type': 'application/json' },
+                    body: { test: 'data' },
+                    params: { id: '123' },
+                    query: { filter: 'active' },
+                },
+            };
+            yield standardLogger.logError(errorData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['http.method']).toBe('POST');
+            (0, vitest_1.expect)(emittedLog.attributes['http.url']).toBe('/api/test');
+            (0, vitest_1.expect)(emittedLog.attributes['http.endpoint']).toBe('/api/test');
+            (0, vitest_1.expect)(emittedLog.attributes['http.status_code']).toBe(500);
+            (0, vitest_1.expect)(emittedLog.attributes['http.headers']).toBe(JSON.stringify({ 'content-type': 'application/json' }));
+            (0, vitest_1.expect)(emittedLog.attributes['http.body']).toBe(JSON.stringify({ test: 'data' }));
+        }));
+        (0, vitest_1.it)('deve incluir informações de usuário quando fornecido', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorData = {
+                message: 'User error',
+                serviceName: 'test-service',
+                environment: 'production',
+                user: {
+                    accountUserUid: 'user-123',
+                    accountUid: 'account-456',
+                    applicationUid: 'app-789',
+                },
+            };
+            yield standardLogger.logError(errorData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['accountUser.uid']).toBe('user-123');
+            (0, vitest_1.expect)(emittedLog.attributes['account.uid']).toBe('account-456');
+            (0, vitest_1.expect)(emittedLog.attributes['application.uid']).toBe('app-789');
+        }));
+        (0, vitest_1.it)('deve incluir informações de execução quando fornecido', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorData = {
+                message: 'Execution error',
+                serviceName: 'test-service',
+                environment: 'production',
+                execution: {
+                    requestId: 'req-123',
+                    awsRequestId: 'aws-456',
+                    functionName: 'testFunction',
+                    invocationId: 'inv-789',
+                    controller: 'TestController',
+                    controllerMethod: 'testMethod',
+                    origin: 'mobile',
+                },
+            };
+            yield standardLogger.logError(errorData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['request.id']).toBe('req-123');
+            (0, vitest_1.expect)(emittedLog.attributes['aws.request.id']).toBe('aws-456');
+            (0, vitest_1.expect)(emittedLog.attributes['faas.name']).toBe('testFunction');
+            (0, vitest_1.expect)(emittedLog.attributes['faas.invocation_id']).toBe('inv-789');
+            (0, vitest_1.expect)(emittedLog.attributes['controller.name']).toBe('TestController');
+            (0, vitest_1.expect)(emittedLog.attributes['controller.method']).toBe('testMethod');
+            (0, vitest_1.expect)(emittedLog.attributes['origin']).toBe('mobile');
+        }));
+        (0, vitest_1.it)('deve incluir métricas de performance quando fornecido', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorData = {
+                message: 'Performance error',
+                serviceName: 'test-service',
+                environment: 'production',
+                performance: {
+                    durationMs: 1500,
+                    success: false,
+                },
+            };
+            yield standardLogger.logError(errorData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['duration.ms']).toBe(1500);
+            (0, vitest_1.expect)(emittedLog.attributes['execution.success']).toBe(false);
+        }));
+        (0, vitest_1.it)('deve incluir contexto adicional quando fornecido', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorData = {
+                message: 'Context error',
+                serviceName: 'test-service',
+                environment: 'production',
+                context: {
+                    additionalInfo: 'some data',
+                    nested: { value: 123 },
+                },
+            };
+            yield standardLogger.logError(errorData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['context']).toBe(JSON.stringify({ additionalInfo: 'some data', nested: { value: 123 } }));
+        }));
+        (0, vitest_1.it)('deve usar serviceName padrão quando não fornecido', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorData = {
+                message: 'Default service error',
+                serviceName: '',
+                environment: 'production',
+            };
+            yield standardLogger.logError(errorData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['service.name']).toBe('test-service');
+        }));
+        (0, vitest_1.it)('deve adicionar timestamp automaticamente', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorData = {
+                message: 'Timestamp test',
+                serviceName: 'test-service',
+                environment: 'production',
+            };
+            yield standardLogger.logError(errorData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['timestamp']).toBeDefined();
+            (0, vitest_1.expect)(emittedLog.attributes['timestamp']).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+        }));
+        (0, vitest_1.it)('deve filtrar valores undefined e null dos atributos', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorData = {
+                message: 'Filter test',
+                serviceName: 'test-service',
+                environment: 'production',
+                user: {
+                    accountUserUid: 'user-123',
+                    accountUid: undefined,
+                    applicationUid: undefined,
+                },
+            };
+            yield standardLogger.logError(errorData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['accountUser.uid']).toBe('user-123');
+            (0, vitest_1.expect)(emittedLog.attributes['account.uid']).toBeUndefined();
+            (0, vitest_1.expect)(emittedLog.attributes['application.uid']).toBeUndefined();
+        }));
+    });
+    (0, vitest_1.describe)('logInfo', () => {
+        (0, vitest_1.it)('deve emitir log com severity INFO', () => __awaiter(void 0, void 0, void 0, function* () {
+            const infoData = {
+                message: 'Info message',
+                serviceName: 'test-service',
+                environment: 'production',
+            };
+            yield standardLogger.logInfo(infoData);
+            (0, vitest_1.expect)(mockLogger.emit).toHaveBeenCalledTimes(1);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.severityNumber).toBe(api_logs_1.SeverityNumber.INFO);
+            (0, vitest_1.expect)(emittedLog.severityText).toBe('INFO');
+            (0, vitest_1.expect)(emittedLog.body).toBe('Info message');
+        }));
+        (0, vitest_1.it)('deve incluir dados de performance em log de sucesso', () => __awaiter(void 0, void 0, void 0, function* () {
+            const infoData = {
+                message: 'Request completed',
+                serviceName: 'test-service',
+                environment: 'production',
+                performance: {
+                    durationMs: 250,
+                    success: true,
+                },
+            };
+            yield standardLogger.logInfo(infoData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['duration.ms']).toBe(250);
+            (0, vitest_1.expect)(emittedLog.attributes['execution.success']).toBe(true);
+        }));
+    });
+    (0, vitest_1.describe)('logWarn', () => {
+        (0, vitest_1.it)('deve emitir log com severity WARN', () => __awaiter(void 0, void 0, void 0, function* () {
+            const warnData = {
+                message: 'Warning message',
+                serviceName: 'test-service',
+                environment: 'production',
+            };
+            yield standardLogger.logWarn(warnData);
+            (0, vitest_1.expect)(mockLogger.emit).toHaveBeenCalledTimes(1);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.severityNumber).toBe(api_logs_1.SeverityNumber.WARN);
+            (0, vitest_1.expect)(emittedLog.severityText).toBe('WARN');
+            (0, vitest_1.expect)(emittedLog.body).toBe('Warning message');
+        }));
+    });
+    (0, vitest_1.describe)('logDebug', () => {
+        (0, vitest_1.it)('deve emitir log com severity DEBUG', () => __awaiter(void 0, void 0, void 0, function* () {
+            const debugData = {
+                message: 'Debug message',
+                serviceName: 'test-service',
+                environment: 'development',
+            };
+            yield standardLogger.logDebug(debugData);
+            (0, vitest_1.expect)(mockLogger.emit).toHaveBeenCalledTimes(1);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.severityNumber).toBe(api_logs_1.SeverityNumber.DEBUG);
+            (0, vitest_1.expect)(emittedLog.severityText).toBe('DEBUG');
+            (0, vitest_1.expect)(emittedLog.body).toBe('Debug message');
+        }));
+    });
+    (0, vitest_1.describe)('buildAttributes', () => {
+        (0, vitest_1.it)('deve construir atributos completos com todos os campos', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fullData = {
+                message: 'Complete log',
+                serviceName: 'complete-service',
+                environment: 'production',
+                error: new Error('Test error'),
+                http: {
+                    method: 'GET',
+                    url: '/api/users',
+                    endpoint: '/api/users',
+                    statusCode: 200,
+                },
+                user: {
+                    accountUserUid: 'user-abc',
+                    accountUid: 'account-xyz',
+                    applicationUid: 'app-123',
+                },
+                execution: {
+                    requestId: 'req-001',
+                    awsRequestId: 'aws-002',
+                    functionName: 'getUsers',
+                    invocationId: 'inv-003',
+                    controller: 'UserController',
+                    controllerMethod: 'getAll',
+                    origin: 'web',
+                },
+                performance: {
+                    durationMs: 300,
+                    success: true,
+                },
+                context: {
+                    custom: 'data',
+                },
+            };
+            yield standardLogger.logInfo(fullData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            const attrs = emittedLog.attributes;
+            (0, vitest_1.expect)(attrs['service.name']).toBe('complete-service');
+            (0, vitest_1.expect)(attrs['deployment.environment.name']).toBe('production');
+            (0, vitest_1.expect)(attrs['error.type']).toBe('Error');
+            (0, vitest_1.expect)(attrs['http.method']).toBe('GET');
+            (0, vitest_1.expect)(attrs['accountUser.uid']).toBe('user-abc');
+            (0, vitest_1.expect)(attrs['request.id']).toBe('req-001');
+            (0, vitest_1.expect)(attrs['duration.ms']).toBe(300);
+            (0, vitest_1.expect)(attrs['context']).toBe(JSON.stringify({ custom: 'data' }));
+        }));
+        (0, vitest_1.it)('deve lidar com campos HTTP parciais', () => __awaiter(void 0, void 0, void 0, function* () {
+            const partialHttpData = {
+                message: 'Partial HTTP',
+                serviceName: 'test-service',
+                environment: 'production',
+                http: {
+                    method: 'POST',
+                    endpoint: '/api/test',
+                },
+            };
+            yield standardLogger.logInfo(partialHttpData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['http.method']).toBe('POST');
+            (0, vitest_1.expect)(emittedLog.attributes['http.endpoint']).toBe('/api/test');
+            (0, vitest_1.expect)(emittedLog.attributes['http.url']).toBeUndefined();
+            (0, vitest_1.expect)(emittedLog.attributes['http.status_code']).toBeUndefined();
+        }));
+    });
+    (0, vitest_1.describe)('construtor', () => {
+        (0, vitest_1.it)('deve aceitar serviceName padrão personalizado', () => {
+            const customLogger = new logger_1.StandardLogger(mockLogger, 'custom-service');
+            const logData = {
+                message: 'Test',
+                serviceName: '',
+                environment: 'test',
+            };
+            customLogger.logInfo(logData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['service.name']).toBe('custom-service');
+        });
+        (0, vitest_1.it)('deve usar "unknown-service" como padrão quando não especificado', () => {
+            const defaultLogger = new logger_1.StandardLogger(mockLogger);
+            const logData = {
+                message: 'Test',
+                serviceName: '',
+                environment: 'test',
+            };
+            defaultLogger.logInfo(logData);
+            const emittedLog = mockLogger.emit.mock.calls[0][0];
+            (0, vitest_1.expect)(emittedLog.attributes['service.name']).toBe('unknown-service');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.test.js","sourceRoot":"","sources":["../../../src/core/__tests__/logger.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, it, expect, vi, beforeEach } from 'vitest';\r\nimport { StandardLogger } from '../logger';\r\nimport { SeverityNumber } from '@opentelemetry/api-logs';\r\n\r\ndescribe('StandardLogger', () => {\r\n  let mockLogger: any;\r\n  let standardLogger: StandardLogger;\r\n\r\n  beforeEach(() => {\r\n    mockLogger = {\r\n      emit: vi.fn(),\r\n    };\r\n    standardLogger = new StandardLogger(mockLogger, 'test-service');\r\n  });\r\n\r\n  describe('logError', () => {\r\n    it('deve emitir log com severity ERROR', async () => {\r\n      const errorData = {\r\n        message: 'Test error message',\r\n        serviceName: 'test-service',\r\n        environment: 'test',\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      expect(mockLogger.emit).toHaveBeenCalledTimes(1);\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.severityNumber).toBe(SeverityNumber.ERROR);\r\n      expect(emittedLog.severityText).toBe('ERROR');\r\n      expect(emittedLog.body).toBe('Test error message');\r\n    });\r\n\r\n    it('deve incluir informações do erro quando fornecido', async () => {\r\n      const error = new Error('Custom error');\r\n      const errorData = {\r\n        message: 'Error occurred',\r\n        error,\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['error.type']).toBe('Error');\r\n      expect(emittedLog.attributes['error.message']).toBe('Custom error');\r\n      expect(emittedLog.attributes['error.stack']).toBeDefined();\r\n    });\r\n\r\n    it('deve incluir contexto HTTP quando fornecido', async () => {\r\n      const errorData = {\r\n        message: 'HTTP error',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n        http: {\r\n          method: 'POST',\r\n          url: '/api/test',\r\n          endpoint: '/api/test',\r\n          statusCode: 500,\r\n          headers: { 'content-type': 'application/json' },\r\n          body: { test: 'data' },\r\n          params: { id: '123' },\r\n          query: { filter: 'active' },\r\n        },\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['http.method']).toBe('POST');\r\n      expect(emittedLog.attributes['http.url']).toBe('/api/test');\r\n      expect(emittedLog.attributes['http.endpoint']).toBe('/api/test');\r\n      expect(emittedLog.attributes['http.status_code']).toBe(500);\r\n      expect(emittedLog.attributes['http.headers']).toBe(\r\n        JSON.stringify({ 'content-type': 'application/json' })\r\n      );\r\n      expect(emittedLog.attributes['http.body']).toBe(\r\n        JSON.stringify({ test: 'data' })\r\n      );\r\n    });\r\n\r\n    it('deve incluir informações de usuário quando fornecido', async () => {\r\n      const errorData = {\r\n        message: 'User error',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n        user: {\r\n          accountUserUid: 'user-123',\r\n          accountUid: 'account-456',\r\n          applicationUid: 'app-789',\r\n        },\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['accountUser.uid']).toBe('user-123');\r\n      expect(emittedLog.attributes['account.uid']).toBe('account-456');\r\n      expect(emittedLog.attributes['application.uid']).toBe('app-789');\r\n    });\r\n\r\n    it('deve incluir informações de execução quando fornecido', async () => {\r\n      const errorData = {\r\n        message: 'Execution error',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n        execution: {\r\n          requestId: 'req-123',\r\n          awsRequestId: 'aws-456',\r\n          functionName: 'testFunction',\r\n          invocationId: 'inv-789',\r\n          controller: 'TestController',\r\n          controllerMethod: 'testMethod',\r\n          origin: 'mobile',\r\n        },\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['request.id']).toBe('req-123');\r\n      expect(emittedLog.attributes['aws.request.id']).toBe('aws-456');\r\n      expect(emittedLog.attributes['faas.name']).toBe('testFunction');\r\n      expect(emittedLog.attributes['faas.invocation_id']).toBe('inv-789');\r\n      expect(emittedLog.attributes['controller.name']).toBe('TestController');\r\n      expect(emittedLog.attributes['controller.method']).toBe('testMethod');\r\n      expect(emittedLog.attributes['origin']).toBe('mobile');\r\n    });\r\n\r\n    it('deve incluir métricas de performance quando fornecido', async () => {\r\n      const errorData = {\r\n        message: 'Performance error',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n        performance: {\r\n          durationMs: 1500,\r\n          success: false,\r\n        },\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['duration.ms']).toBe(1500);\r\n      expect(emittedLog.attributes['execution.success']).toBe(false);\r\n    });\r\n\r\n    it('deve incluir contexto adicional quando fornecido', async () => {\r\n      const errorData = {\r\n        message: 'Context error',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n        context: {\r\n          additionalInfo: 'some data',\r\n          nested: { value: 123 },\r\n        },\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['context']).toBe(\r\n        JSON.stringify({ additionalInfo: 'some data', nested: { value: 123 } })\r\n      );\r\n    });\r\n\r\n    it('deve usar serviceName padrão quando não fornecido', async () => {\r\n      const errorData = {\r\n        message: 'Default service error',\r\n        serviceName: '', // Empty string para testar fallback\r\n        environment: 'production',\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['service.name']).toBe('test-service');\r\n    });\r\n\r\n    it('deve adicionar timestamp automaticamente', async () => {\r\n      const errorData = {\r\n        message: 'Timestamp test',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['timestamp']).toBeDefined();\r\n      expect(emittedLog.attributes['timestamp']).toMatch(\r\n        /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$/\r\n      );\r\n    });\r\n\r\n    it('deve filtrar valores undefined e null dos atributos', async () => {\r\n      const errorData = {\r\n        message: 'Filter test',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n        user: {\r\n          accountUserUid: 'user-123',\r\n          accountUid: undefined as any,\r\n          applicationUid: undefined as any,\r\n        },\r\n      };\r\n\r\n      await standardLogger.logError(errorData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['accountUser.uid']).toBe('user-123');\r\n      expect(emittedLog.attributes['account.uid']).toBeUndefined();\r\n      expect(emittedLog.attributes['application.uid']).toBeUndefined();\r\n    });\r\n  });\r\n\r\n  describe('logInfo', () => {\r\n    it('deve emitir log com severity INFO', async () => {\r\n      const infoData = {\r\n        message: 'Info message',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n      };\r\n\r\n      await standardLogger.logInfo(infoData);\r\n\r\n      expect(mockLogger.emit).toHaveBeenCalledTimes(1);\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.severityNumber).toBe(SeverityNumber.INFO);\r\n      expect(emittedLog.severityText).toBe('INFO');\r\n      expect(emittedLog.body).toBe('Info message');\r\n    });\r\n\r\n    it('deve incluir dados de performance em log de sucesso', async () => {\r\n      const infoData = {\r\n        message: 'Request completed',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n        performance: {\r\n          durationMs: 250,\r\n          success: true,\r\n        },\r\n      };\r\n\r\n      await standardLogger.logInfo(infoData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['duration.ms']).toBe(250);\r\n      expect(emittedLog.attributes['execution.success']).toBe(true);\r\n    });\r\n  });\r\n\r\n  describe('logWarn', () => {\r\n    it('deve emitir log com severity WARN', async () => {\r\n      const warnData = {\r\n        message: 'Warning message',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n      };\r\n\r\n      await standardLogger.logWarn(warnData);\r\n\r\n      expect(mockLogger.emit).toHaveBeenCalledTimes(1);\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.severityNumber).toBe(SeverityNumber.WARN);\r\n      expect(emittedLog.severityText).toBe('WARN');\r\n      expect(emittedLog.body).toBe('Warning message');\r\n    });\r\n  });\r\n\r\n  describe('logDebug', () => {\r\n    it('deve emitir log com severity DEBUG', async () => {\r\n      const debugData = {\r\n        message: 'Debug message',\r\n        serviceName: 'test-service',\r\n        environment: 'development',\r\n      };\r\n\r\n      await standardLogger.logDebug(debugData);\r\n\r\n      expect(mockLogger.emit).toHaveBeenCalledTimes(1);\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.severityNumber).toBe(SeverityNumber.DEBUG);\r\n      expect(emittedLog.severityText).toBe('DEBUG');\r\n      expect(emittedLog.body).toBe('Debug message');\r\n    });\r\n  });\r\n\r\n  describe('buildAttributes', () => {\r\n    it('deve construir atributos completos com todos os campos', async () => {\r\n      const fullData = {\r\n        message: 'Complete log',\r\n        serviceName: 'complete-service',\r\n        environment: 'production',\r\n        error: new Error('Test error'),\r\n        http: {\r\n          method: 'GET',\r\n          url: '/api/users',\r\n          endpoint: '/api/users',\r\n          statusCode: 200,\r\n        },\r\n        user: {\r\n          accountUserUid: 'user-abc',\r\n          accountUid: 'account-xyz',\r\n          applicationUid: 'app-123',\r\n        },\r\n        execution: {\r\n          requestId: 'req-001',\r\n          awsRequestId: 'aws-002',\r\n          functionName: 'getUsers',\r\n          invocationId: 'inv-003',\r\n          controller: 'UserController',\r\n          controllerMethod: 'getAll',\r\n          origin: 'web',\r\n        },\r\n        performance: {\r\n          durationMs: 300,\r\n          success: true,\r\n        },\r\n        context: {\r\n          custom: 'data',\r\n        },\r\n      };\r\n\r\n      await standardLogger.logInfo(fullData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      const attrs = emittedLog.attributes;\r\n\r\n      // Verificar todos os campos\r\n      expect(attrs['service.name']).toBe('complete-service');\r\n      expect(attrs['deployment.environment.name']).toBe('production');\r\n      expect(attrs['error.type']).toBe('Error');\r\n      expect(attrs['http.method']).toBe('GET');\r\n      expect(attrs['accountUser.uid']).toBe('user-abc');\r\n      expect(attrs['request.id']).toBe('req-001');\r\n      expect(attrs['duration.ms']).toBe(300);\r\n      expect(attrs['context']).toBe(JSON.stringify({ custom: 'data' }));\r\n    });\r\n\r\n    it('deve lidar com campos HTTP parciais', async () => {\r\n      const partialHttpData = {\r\n        message: 'Partial HTTP',\r\n        serviceName: 'test-service',\r\n        environment: 'production',\r\n        http: {\r\n          method: 'POST',\r\n          endpoint: '/api/test',\r\n          // url, statusCode, headers, etc não fornecidos\r\n        },\r\n      };\r\n\r\n      await standardLogger.logInfo(partialHttpData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['http.method']).toBe('POST');\r\n      expect(emittedLog.attributes['http.endpoint']).toBe('/api/test');\r\n      expect(emittedLog.attributes['http.url']).toBeUndefined();\r\n      expect(emittedLog.attributes['http.status_code']).toBeUndefined();\r\n    });\r\n  });\r\n\r\n  describe('construtor', () => {\r\n    it('deve aceitar serviceName padrão personalizado', () => {\r\n      const customLogger = new StandardLogger(mockLogger, 'custom-service');\r\n      const logData = {\r\n        message: 'Test',\r\n        serviceName: '',\r\n        environment: 'test',\r\n      };\r\n\r\n      customLogger.logInfo(logData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['service.name']).toBe('custom-service');\r\n    });\r\n\r\n    it('deve usar \"unknown-service\" como padrão quando não especificado', () => {\r\n      const defaultLogger = new StandardLogger(mockLogger);\r\n      const logData = {\r\n        message: 'Test',\r\n        serviceName: '',\r\n        environment: 'test',\r\n      };\r\n\r\n      defaultLogger.logInfo(logData);\r\n\r\n      const emittedLog = mockLogger.emit.mock.calls[0][0];\r\n      expect(emittedLog.attributes['service.name']).toBe('unknown-service');\r\n    });\r\n  });\r\n});\r\n"]}

package/dist/core/__tests__/tracer.test.d.ts

@@ -0,0 +1 @@
+export {};