@mecanizou/telemetry-hub 1.0.0 → 1.0.2

package/dist/telemetry/core/__tests__/tracer.test.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const tracer_1 = require("../tracer");
+const api_1 = require("@opentelemetry/api");
+(0, vitest_1.describe)('StandardTracer', () => {
+    let mockTracer;
+    let mockSpan;
+    let standardTracer;
+    (0, vitest_1.beforeEach)(() => {
+        mockSpan = {
+            end: vitest_1.vi.fn(),
+            setAttribute: vitest_1.vi.fn(),
+            setStatus: vitest_1.vi.fn(),
+            recordException: vitest_1.vi.fn(),
+        };
+        mockTracer = {
+            startSpan: vitest_1.vi.fn().mockReturnValue(mockSpan),
+        };
+        standardTracer = new tracer_1.StandardTracer(mockTracer, 'test-service');
+    });
+    (0, vitest_1.describe)('startSpan', () => {
+        (0, vitest_1.it)('deve criar span com nome e atributos básicos', () => {
+            const spanResult = standardTracer.startSpan({
+                spanName: 'test-operation',
+                serviceName: 'my-service',
+                environment: 'production',
+            });
+            (0, vitest_1.expect)(mockTracer.startSpan).toHaveBeenCalledWith('test-operation', {
+                kind: api_1.SpanKind.SERVER,
+                attributes: {
+                    'service.name': 'my-service',
+                    'deployment.environment.name': 'production',
+                },
+            });
+            (0, vitest_1.expect)(spanResult.span).toBe(mockSpan);
+            (0, vitest_1.expect)(spanResult.end).toBeDefined();
+            (0, vitest_1.expect)(spanResult.setSuccess).toBeDefined();
+            (0, vitest_1.expect)(spanResult.setError).toBeDefined();
+            (0, vitest_1.expect)(spanResult.setAttribute).toBeDefined();
+        });
+        (0, vitest_1.it)('deve usar defaultServiceName quando serviceName não fornecido', () => {
+            standardTracer.startSpan({
+                spanName: 'test-operation',
+                serviceName: '',
+                environment: 'test',
+            });
+            const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;
+            (0, vitest_1.expect)(attributes['service.name']).toBe('test-service');
+        });
+        (0, vitest_1.it)('deve incluir atributos de execução', () => {
+            standardTracer.startSpan({
+                spanName: 'process-request',
+                serviceName: 'api-service',
+                environment: 'production',
+                execution: {
+                    functionName: 'processPayment',
+                    invocationId: 'inv-123',
+                    awsRequestId: 'aws-456',
+                    requestId: 'req-789',
+                    controller: 'PaymentController',
+                    controllerMethod: 'process',
+                    origin: 'mobile',
+                },
+            });
+            const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;
+            (0, vitest_1.expect)(attributes['faas.name']).toBe('processPayment');
+            (0, vitest_1.expect)(attributes['faas.invocation_id']).toBe('inv-123');
+            (0, vitest_1.expect)(attributes['aws.request.id']).toBe('aws-456');
+            (0, vitest_1.expect)(attributes['request.id']).toBe('req-789');
+            (0, vitest_1.expect)(attributes['controller.name']).toBe('PaymentController');
+            (0, vitest_1.expect)(attributes['controller.method']).toBe('process');
+            (0, vitest_1.expect)(attributes['origin']).toBe('mobile');
+        });
+        (0, vitest_1.it)('deve incluir atributos HTTP', () => {
+            standardTracer.startSpan({
+                spanName: 'http-request',
+                serviceName: 'web-service',
+                environment: 'production',
+                http: {
+                    method: 'POST',
+                    url: 'https://api.example.com/orders',
+                    endpoint: '/orders',
+                    statusCode: 201,
+                    scheme: 'https',
+                    host: 'api.example.com',
+                },
+            });
+            const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;
+            (0, vitest_1.expect)(attributes['http.method']).toBe('POST');
+            (0, vitest_1.expect)(attributes['http.url']).toBe('https://api.example.com/orders');
+            (0, vitest_1.expect)(attributes['http.target']).toBe('/orders');
+            (0, vitest_1.expect)(attributes['http.status_code']).toBe(201);
+            (0, vitest_1.expect)(attributes['http.scheme']).toBe('https');
+            (0, vitest_1.expect)(attributes['http.host']).toBe('api.example.com');
+        });
+        (0, vitest_1.it)('deve incluir atributos de usuário', () => {
+            standardTracer.startSpan({
+                spanName: 'user-operation',
+                serviceName: 'user-service',
+                environment: 'production',
+                user: {
+                    accountUserUid: 'user-123',
+                    accountUid: 'account-456',
+                    applicationUid: 'app-789',
+                },
+            });
+            const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;
+            (0, vitest_1.expect)(attributes['accountUser.uid']).toBe('user-123');
+            (0, vitest_1.expect)(attributes['account.uid']).toBe('account-456');
+            (0, vitest_1.expect)(attributes['application.uid']).toBe('app-789');
+        });
+        (0, vitest_1.it)('deve incluir atributos de performance', () => {
+            standardTracer.startSpan({
+                spanName: 'performance-test',
+                serviceName: 'perf-service',
+                environment: 'test',
+                performance: {
+                    durationMs: 250,
+                    success: true,
+                },
+            });
+            const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;
+            (0, vitest_1.expect)(attributes['duration.ms']).toBe(250);
+            (0, vitest_1.expect)(attributes['execution.success']).toBe(true);
+        });
+        (0, vitest_1.it)('deve incluir atributos de erro', () => {
+            standardTracer.startSpan({
+                spanName: 'error-operation',
+                serviceName: 'error-service',
+                environment: 'production',
+                error: {
+                    type: 'ValidationError',
+                    message: 'Invalid input',
+                    stack: 'Error stack trace',
+                },
+            });
+            const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;
+            (0, vitest_1.expect)(attributes['error.type']).toBe('ValidationError');
+            (0, vitest_1.expect)(attributes['error.message']).toBe('Invalid input');
+            (0, vitest_1.expect)(attributes['error.stack']).toBe('Error stack trace');
+        });
+        (0, vitest_1.it)('deve incluir atributos customizados', () => {
+            standardTracer.startSpan({
+                spanName: 'custom-operation',
+                serviceName: 'custom-service',
+                environment: 'production',
+                attributes: {
+                    'custom.field': 'value',
+                    'custom.count': 42,
+                    'custom.enabled': true,
+                },
+            });
+            const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;
+            (0, vitest_1.expect)(attributes['custom.field']).toBe('value');
+            (0, vitest_1.expect)(attributes['custom.count']).toBe(42);
+            (0, vitest_1.expect)(attributes['custom.enabled']).toBe(true);
+        });
+        (0, vitest_1.it)('deve filtrar valores undefined e null', () => {
+            standardTracer.startSpan({
+                spanName: 'filter-test',
+                serviceName: 'filter-service',
+                environment: 'production',
+                execution: {
+                    functionName: 'test',
+                    invocationId: undefined,
+                    awsRequestId: null,
+                },
+                attributes: {
+                    valid: 'value',
+                    invalid: undefined,
+                    nullValue: null,
+                },
+            });
+            const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;
+            (0, vitest_1.expect)(attributes['faas.name']).toBe('test');
+            (0, vitest_1.expect)(attributes['faas.invocation_id']).toBeUndefined();
+            (0, vitest_1.expect)(attributes['aws.request.id']).toBeUndefined();
+            (0, vitest_1.expect)(attributes['valid']).toBe('value');
+            (0, vitest_1.expect)(attributes['invalid']).toBeUndefined();
+            (0, vitest_1.expect)(attributes['nullValue']).toBeUndefined();
+        });
+    });
+    (0, vitest_1.describe)('StandardSpanResult', () => {
+        let spanResult;
+        (0, vitest_1.beforeEach)(() => {
+            spanResult = standardTracer.startSpan({
+                spanName: 'test-span',
+                serviceName: 'test-service',
+                environment: 'test',
+            });
+        });
+        (0, vitest_1.describe)('end', () => {
+            (0, vitest_1.it)('deve finalizar o span', () => {
+                spanResult.end();
+                (0, vitest_1.expect)(mockSpan.end).toHaveBeenCalledTimes(1);
+            });
+        });
+        (0, vitest_1.describe)('setSuccess', () => {
+            (0, vitest_1.it)('deve marcar span como sucesso', () => {
+                spanResult.setSuccess(true);
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('execution.success', true);
+                (0, vitest_1.expect)(mockSpan.setStatus).toHaveBeenCalledWith({
+                    code: api_1.SpanStatusCode.OK,
+                });
+            });
+            (0, vitest_1.it)('deve marcar span como falha', () => {
+                spanResult.setSuccess(false);
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('execution.success', false);
+                (0, vitest_1.expect)(mockSpan.setStatus).toHaveBeenCalledWith({
+                    code: api_1.SpanStatusCode.ERROR,
+                });
+            });
+        });
+        (0, vitest_1.describe)('setError', () => {
+            (0, vitest_1.it)('deve registrar erro no span', () => {
+                const error = new Error('Test error');
+                spanResult.setError(error);
+                (0, vitest_1.expect)(mockSpan.recordException).toHaveBeenCalledWith(error);
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.type', 'Error');
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.message', 'Test error');
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('execution.success', false);
+                (0, vitest_1.expect)(mockSpan.setStatus).toHaveBeenCalledWith({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: 'Test error',
+                });
+            });
+            (0, vitest_1.it)('deve incluir stack trace quando disponível', () => {
+                const error = new Error('Error with stack');
+                error.stack = 'Error: Error with stack\n  at test.ts:1:1';
+                spanResult.setError(error);
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.stack', error.stack);
+            });
+            (0, vitest_1.it)('deve funcionar com erro customizado', () => {
+                class CustomError extends Error {
+                    constructor(message) {
+                        super(message);
+                        this.name = 'CustomError';
+                    }
+                }
+                const error = new CustomError('Custom error message');
+                spanResult.setError(error);
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.type', 'CustomError');
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.message', 'Custom error message');
+            });
+        });
+        (0, vitest_1.describe)('setAttribute', () => {
+            (0, vitest_1.it)('deve adicionar atributo string', () => {
+                spanResult.setAttribute('custom.key', 'custom value');
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('custom.key', 'custom value');
+            });
+            (0, vitest_1.it)('deve adicionar atributo numérico', () => {
+                spanResult.setAttribute('custom.count', 123);
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('custom.count', 123);
+            });
+            (0, vitest_1.it)('deve adicionar atributo booleano', () => {
+                spanResult.setAttribute('custom.enabled', true);
+                (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('custom.enabled', true);
+            });
+        });
+    });
+    (0, vitest_1.describe)('recordException', () => {
+        (0, vitest_1.it)('deve registrar exceção com todos os atributos', () => {
+            const error = new Error('Exception test');
+            error.stack = 'Error stack trace here';
+            standardTracer.recordException(mockSpan, error);
+            (0, vitest_1.expect)(mockSpan.recordException).toHaveBeenCalledWith(error);
+            (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.type', 'Error');
+            (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.message', 'Exception test');
+            (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.stack', 'Error stack trace here');
+        });
+        (0, vitest_1.it)('deve funcionar sem stack trace', () => {
+            const error = new Error('No stack');
+            delete error.stack;
+            standardTracer.recordException(mockSpan, error);
+            (0, vitest_1.expect)(mockSpan.recordException).toHaveBeenCalledWith(error);
+            (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.type', 'Error');
+            (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('error.message', 'No stack');
+            (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledTimes(2);
+        });
+    });
+    (0, vitest_1.describe)('cenários de uso completos', () => {
+        (0, vitest_1.it)('deve gerenciar fluxo de sucesso completo', () => {
+            const spanResult = standardTracer.startSpan({
+                spanName: 'complete-operation',
+                serviceName: 'complete-service',
+                environment: 'production',
+                execution: {
+                    functionName: 'processData',
+                    requestId: 'req-123',
+                },
+                http: {
+                    method: 'POST',
+                    endpoint: '/api/data',
+                },
+            });
+            spanResult.setAttribute('custom.step', 'processing');
+            spanResult.setSuccess(true);
+            spanResult.end();
+            (0, vitest_1.expect)(mockTracer.startSpan).toHaveBeenCalled();
+            (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('custom.step', 'processing');
+            (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('execution.success', true);
+            (0, vitest_1.expect)(mockSpan.setStatus).toHaveBeenCalledWith({
+                code: api_1.SpanStatusCode.OK,
+            });
+            (0, vitest_1.expect)(mockSpan.end).toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('deve gerenciar fluxo de erro completo', () => {
+            const spanResult = standardTracer.startSpan({
+                spanName: 'error-operation',
+                serviceName: 'error-service',
+                environment: 'production',
+                user: {
+                    accountUserUid: 'user-123',
+                },
+            });
+            const error = new Error('Operation failed');
+            spanResult.setError(error);
+            spanResult.end();
+            (0, vitest_1.expect)(mockSpan.recordException).toHaveBeenCalledWith(error);
+            (0, vitest_1.expect)(mockSpan.setAttribute).toHaveBeenCalledWith('execution.success', false);
+            (0, vitest_1.expect)(mockSpan.setStatus).toHaveBeenCalledWith({
+                code: api_1.SpanStatusCode.ERROR,
+                message: 'Operation failed',
+            });
+            (0, vitest_1.expect)(mockSpan.end).toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tracer.test.js","sourceRoot":"","sources":["../../../../src/telemetry/core/__tests__/tracer.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, it, expect, vi, beforeEach } from 'vitest';\r\nimport { StandardTracer } from '../tracer';\r\nimport { SpanStatusCode, SpanKind } from '@opentelemetry/api';\r\n\r\ndescribe('StandardTracer', () => {\r\n  let mockTracer: any;\r\n  let mockSpan: any;\r\n  let standardTracer: StandardTracer;\r\n\r\n  beforeEach(() => {\r\n    mockSpan = {\r\n      end: vi.fn(),\r\n      setAttribute: vi.fn(),\r\n      setStatus: vi.fn(),\r\n      recordException: vi.fn(),\r\n    };\r\n\r\n    mockTracer = {\r\n      startSpan: vi.fn().mockReturnValue(mockSpan),\r\n    };\r\n\r\n    standardTracer = new StandardTracer(mockTracer, 'test-service');\r\n  });\r\n\r\n  describe('startSpan', () => {\r\n    it('deve criar span com nome e atributos básicos', () => {\r\n      const spanResult = standardTracer.startSpan({\r\n        spanName: 'test-operation',\r\n        serviceName: 'my-service',\r\n        environment: 'production',\r\n      });\r\n\r\n      expect(mockTracer.startSpan).toHaveBeenCalledWith('test-operation', {\r\n        kind: SpanKind.SERVER,\r\n        attributes: {\r\n          'service.name': 'my-service',\r\n          'deployment.environment.name': 'production',\r\n        },\r\n      });\r\n\r\n      expect(spanResult.span).toBe(mockSpan);\r\n      expect(spanResult.end).toBeDefined();\r\n      expect(spanResult.setSuccess).toBeDefined();\r\n      expect(spanResult.setError).toBeDefined();\r\n      expect(spanResult.setAttribute).toBeDefined();\r\n    });\r\n\r\n    it('deve usar defaultServiceName quando serviceName não fornecido', () => {\r\n      standardTracer.startSpan({\r\n        spanName: 'test-operation',\r\n        serviceName: '',\r\n        environment: 'test',\r\n      });\r\n\r\n      const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;\r\n      expect(attributes['service.name']).toBe('test-service');\r\n    });\r\n\r\n    it('deve incluir atributos de execução', () => {\r\n      standardTracer.startSpan({\r\n        spanName: 'process-request',\r\n        serviceName: 'api-service',\r\n        environment: 'production',\r\n        execution: {\r\n          functionName: 'processPayment',\r\n          invocationId: 'inv-123',\r\n          awsRequestId: 'aws-456',\r\n          requestId: 'req-789',\r\n          controller: 'PaymentController',\r\n          controllerMethod: 'process',\r\n          origin: 'mobile',\r\n        },\r\n      });\r\n\r\n      const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;\r\n      expect(attributes['faas.name']).toBe('processPayment');\r\n      expect(attributes['faas.invocation_id']).toBe('inv-123');\r\n      expect(attributes['aws.request.id']).toBe('aws-456');\r\n      expect(attributes['request.id']).toBe('req-789');\r\n      expect(attributes['controller.name']).toBe('PaymentController');\r\n      expect(attributes['controller.method']).toBe('process');\r\n      expect(attributes['origin']).toBe('mobile');\r\n    });\r\n\r\n    it('deve incluir atributos HTTP', () => {\r\n      standardTracer.startSpan({\r\n        spanName: 'http-request',\r\n        serviceName: 'web-service',\r\n        environment: 'production',\r\n        http: {\r\n          method: 'POST',\r\n          url: 'https://api.example.com/orders',\r\n          endpoint: '/orders',\r\n          statusCode: 201,\r\n          scheme: 'https',\r\n          host: 'api.example.com',\r\n        },\r\n      });\r\n\r\n      const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;\r\n      expect(attributes['http.method']).toBe('POST');\r\n      expect(attributes['http.url']).toBe('https://api.example.com/orders');\r\n      expect(attributes['http.target']).toBe('/orders');\r\n      expect(attributes['http.status_code']).toBe(201);\r\n      expect(attributes['http.scheme']).toBe('https');\r\n      expect(attributes['http.host']).toBe('api.example.com');\r\n    });\r\n\r\n    it('deve incluir atributos de usuário', () => {\r\n      standardTracer.startSpan({\r\n        spanName: 'user-operation',\r\n        serviceName: 'user-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      const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;\r\n      expect(attributes['accountUser.uid']).toBe('user-123');\r\n      expect(attributes['account.uid']).toBe('account-456');\r\n      expect(attributes['application.uid']).toBe('app-789');\r\n    });\r\n\r\n    it('deve incluir atributos de performance', () => {\r\n      standardTracer.startSpan({\r\n        spanName: 'performance-test',\r\n        serviceName: 'perf-service',\r\n        environment: 'test',\r\n        performance: {\r\n          durationMs: 250,\r\n          success: true,\r\n        },\r\n      });\r\n\r\n      const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;\r\n      expect(attributes['duration.ms']).toBe(250);\r\n      expect(attributes['execution.success']).toBe(true);\r\n    });\r\n\r\n    it('deve incluir atributos de erro', () => {\r\n      standardTracer.startSpan({\r\n        spanName: 'error-operation',\r\n        serviceName: 'error-service',\r\n        environment: 'production',\r\n        error: {\r\n          type: 'ValidationError',\r\n          message: 'Invalid input',\r\n          stack: 'Error stack trace',\r\n        },\r\n      });\r\n\r\n      const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;\r\n      expect(attributes['error.type']).toBe('ValidationError');\r\n      expect(attributes['error.message']).toBe('Invalid input');\r\n      expect(attributes['error.stack']).toBe('Error stack trace');\r\n    });\r\n\r\n    it('deve incluir atributos customizados', () => {\r\n      standardTracer.startSpan({\r\n        spanName: 'custom-operation',\r\n        serviceName: 'custom-service',\r\n        environment: 'production',\r\n        attributes: {\r\n          'custom.field': 'value',\r\n          'custom.count': 42,\r\n          'custom.enabled': true,\r\n        },\r\n      });\r\n\r\n      const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;\r\n      expect(attributes['custom.field']).toBe('value');\r\n      expect(attributes['custom.count']).toBe(42);\r\n      expect(attributes['custom.enabled']).toBe(true);\r\n    });\r\n\r\n    it('deve filtrar valores undefined e null', () => {\r\n      standardTracer.startSpan({\r\n        spanName: 'filter-test',\r\n        serviceName: 'filter-service',\r\n        environment: 'production',\r\n        execution: {\r\n          functionName: 'test',\r\n          invocationId: undefined,\r\n          awsRequestId: null as any,\r\n        },\r\n        attributes: {\r\n          valid: 'value',\r\n          invalid: undefined as any,\r\n          nullValue: null as any,\r\n        },\r\n      });\r\n\r\n      const attributes = mockTracer.startSpan.mock.calls[0][1].attributes;\r\n      expect(attributes['faas.name']).toBe('test');\r\n      expect(attributes['faas.invocation_id']).toBeUndefined();\r\n      expect(attributes['aws.request.id']).toBeUndefined();\r\n      expect(attributes['valid']).toBe('value');\r\n      expect(attributes['invalid']).toBeUndefined();\r\n      expect(attributes['nullValue']).toBeUndefined();\r\n    });\r\n  });\r\n\r\n  describe('StandardSpanResult', () => {\r\n    let spanResult: any;\r\n\r\n    beforeEach(() => {\r\n      spanResult = standardTracer.startSpan({\r\n        spanName: 'test-span',\r\n        serviceName: 'test-service',\r\n        environment: 'test',\r\n      });\r\n    });\r\n\r\n    describe('end', () => {\r\n      it('deve finalizar o span', () => {\r\n        spanResult.end();\r\n\r\n        expect(mockSpan.end).toHaveBeenCalledTimes(1);\r\n      });\r\n    });\r\n\r\n    describe('setSuccess', () => {\r\n      it('deve marcar span como sucesso', () => {\r\n        spanResult.setSuccess(true);\r\n\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'execution.success',\r\n          true\r\n        );\r\n        expect(mockSpan.setStatus).toHaveBeenCalledWith({\r\n          code: SpanStatusCode.OK,\r\n        });\r\n      });\r\n\r\n      it('deve marcar span como falha', () => {\r\n        spanResult.setSuccess(false);\r\n\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'execution.success',\r\n          false\r\n        );\r\n        expect(mockSpan.setStatus).toHaveBeenCalledWith({\r\n          code: SpanStatusCode.ERROR,\r\n        });\r\n      });\r\n    });\r\n\r\n    describe('setError', () => {\r\n      it('deve registrar erro no span', () => {\r\n        const error = new Error('Test error');\r\n\r\n        spanResult.setError(error);\r\n\r\n        expect(mockSpan.recordException).toHaveBeenCalledWith(error);\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'error.type',\r\n          'Error'\r\n        );\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'error.message',\r\n          'Test error'\r\n        );\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'execution.success',\r\n          false\r\n        );\r\n        expect(mockSpan.setStatus).toHaveBeenCalledWith({\r\n          code: SpanStatusCode.ERROR,\r\n          message: 'Test error',\r\n        });\r\n      });\r\n\r\n      it('deve incluir stack trace quando disponível', () => {\r\n        const error = new Error('Error with stack');\r\n        error.stack = 'Error: Error with stack\\n  at test.ts:1:1';\r\n\r\n        spanResult.setError(error);\r\n\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'error.stack',\r\n          error.stack\r\n        );\r\n      });\r\n\r\n      it('deve funcionar com erro customizado', () => {\r\n        class CustomError extends Error {\r\n          constructor(message: string) {\r\n            super(message);\r\n            this.name = 'CustomError';\r\n          }\r\n        }\r\n\r\n        const error = new CustomError('Custom error message');\r\n\r\n        spanResult.setError(error);\r\n\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'error.type',\r\n          'CustomError'\r\n        );\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'error.message',\r\n          'Custom error message'\r\n        );\r\n      });\r\n    });\r\n\r\n    describe('setAttribute', () => {\r\n      it('deve adicionar atributo string', () => {\r\n        spanResult.setAttribute('custom.key', 'custom value');\r\n\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'custom.key',\r\n          'custom value'\r\n        );\r\n      });\r\n\r\n      it('deve adicionar atributo numérico', () => {\r\n        spanResult.setAttribute('custom.count', 123);\r\n\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith('custom.count', 123);\r\n      });\r\n\r\n      it('deve adicionar atributo booleano', () => {\r\n        spanResult.setAttribute('custom.enabled', true);\r\n\r\n        expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n          'custom.enabled',\r\n          true\r\n        );\r\n      });\r\n    });\r\n  });\r\n\r\n  describe('recordException', () => {\r\n    it('deve registrar exceção com todos os atributos', () => {\r\n      const error = new Error('Exception test');\r\n      error.stack = 'Error stack trace here';\r\n\r\n      standardTracer.recordException(mockSpan, error);\r\n\r\n      expect(mockSpan.recordException).toHaveBeenCalledWith(error);\r\n      expect(mockSpan.setAttribute).toHaveBeenCalledWith('error.type', 'Error');\r\n      expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n        'error.message',\r\n        'Exception test'\r\n      );\r\n      expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n        'error.stack',\r\n        'Error stack trace here'\r\n      );\r\n    });\r\n\r\n    it('deve funcionar sem stack trace', () => {\r\n      const error = new Error('No stack');\r\n      delete error.stack;\r\n\r\n      standardTracer.recordException(mockSpan, error);\r\n\r\n      expect(mockSpan.recordException).toHaveBeenCalledWith(error);\r\n      expect(mockSpan.setAttribute).toHaveBeenCalledWith('error.type', 'Error');\r\n      expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n        'error.message',\r\n        'No stack'\r\n      );\r\n      expect(mockSpan.setAttribute).toHaveBeenCalledTimes(2); // Apenas type e message\r\n    });\r\n  });\r\n\r\n  describe('cenários de uso completos', () => {\r\n    it('deve gerenciar fluxo de sucesso completo', () => {\r\n      const spanResult = standardTracer.startSpan({\r\n        spanName: 'complete-operation',\r\n        serviceName: 'complete-service',\r\n        environment: 'production',\r\n        execution: {\r\n          functionName: 'processData',\r\n          requestId: 'req-123',\r\n        },\r\n        http: {\r\n          method: 'POST',\r\n          endpoint: '/api/data',\r\n        },\r\n      });\r\n\r\n      spanResult.setAttribute('custom.step', 'processing');\r\n      spanResult.setSuccess(true);\r\n      spanResult.end();\r\n\r\n      expect(mockTracer.startSpan).toHaveBeenCalled();\r\n      expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n        'custom.step',\r\n        'processing'\r\n      );\r\n      expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n        'execution.success',\r\n        true\r\n      );\r\n      expect(mockSpan.setStatus).toHaveBeenCalledWith({\r\n        code: SpanStatusCode.OK,\r\n      });\r\n      expect(mockSpan.end).toHaveBeenCalled();\r\n    });\r\n\r\n    it('deve gerenciar fluxo de erro completo', () => {\r\n      const spanResult = standardTracer.startSpan({\r\n        spanName: 'error-operation',\r\n        serviceName: 'error-service',\r\n        environment: 'production',\r\n        user: {\r\n          accountUserUid: 'user-123',\r\n        },\r\n      });\r\n\r\n      const error = new Error('Operation failed');\r\n\r\n      spanResult.setError(error);\r\n      spanResult.end();\r\n\r\n      expect(mockSpan.recordException).toHaveBeenCalledWith(error);\r\n      expect(mockSpan.setAttribute).toHaveBeenCalledWith(\r\n        'execution.success',\r\n        false\r\n      );\r\n      expect(mockSpan.setStatus).toHaveBeenCalledWith({\r\n        code: SpanStatusCode.ERROR,\r\n        message: 'Operation failed',\r\n      });\r\n      expect(mockSpan.end).toHaveBeenCalled();\r\n    });\r\n  });\r\n});\r\n"]}

package/dist/telemetry/core/index.d.ts

@@ -0,0 +1,4 @@
+export { StandardLogger } from './logger';
+export { IStandardLogger, StandardLogData } from './logger-types';
+export { StandardTracer } from './tracer';
+export { IStandardTracer, StandardTraceData, StandardSpanResult, } from './tracer-types';

package/dist/telemetry/core/index.js

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

package/dist/telemetry/core/logger-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/telemetry/core/logger-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/telemetry/core/logger.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from '@opentelemetry/api-logs';
+import { IStandardLogger, StandardLogData } from './logger-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/telemetry/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":"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","sourcesContent":["import { SeverityNumber, Logger } from '@opentelemetry/api-logs';\r\nimport { IStandardLogger, StandardLogData } from './logger-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"]}