@mecanizou/telemetry-hub 1.0.0 → 1.0.2

package/dist/sst/telemetry.js

@@ -0,0 +1,121 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.forceFlush = exports.getStandardTracer = exports.getStandardLogger = void 0;
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const logs = __importStar(require("@opentelemetry/sdk-logs"));
+const resources = __importStar(require("@opentelemetry/resources"));
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("../core");
+const user = process.env.OTEL_EXPORTER_OTLP_USER;
+const password = process.env.OTEL_EXPORTER_OTLP_PASS;
+const basicAuth = Buffer.from(`${user}:${password}`).toString('base64');
+const baseUrl = `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT}/v1`;
+const traceExporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({
+    url: `${baseUrl}/traces`,
+    headers: {
+        Authorization: `Basic ${basicAuth}`,
+        'Content-Type': 'application/json',
+    },
+});
+const metricExporter = new exporter_metrics_otlp_http_1.OTLPMetricExporter({
+    url: `${baseUrl}/metrics`,
+    headers: {
+        Authorization: `Basic ${basicAuth}`,
+        'Content-Type': 'application/json',
+    },
+});
+const logExporter = new exporter_logs_otlp_http_1.OTLPLogExporter({
+    url: `${baseUrl}/logs`,
+    headers: {
+        Authorization: `Basic ${basicAuth}`,
+        'Content-Type': 'application/json',
+    },
+});
+const metricReader = new sdk_metrics_1.PeriodicExportingMetricReader({
+    exporter: metricExporter,
+    exportIntervalMillis: 1000,
+});
+const serviceName = process.env.SERVICE_NAME || 'sst-service';
+const resource = new resources.Resource({
+    [semantic_conventions_1.ATTR_SERVICE_NAME]: serviceName,
+});
+const loggerProvider = new logs.LoggerProvider({ resource });
+const logRecordProcessor = new logs.BatchLogRecordProcessor(logExporter);
+loggerProvider.addLogRecordProcessor(logRecordProcessor);
+const sdk = new sdk_node_1.NodeSDK({
+    traceExporter,
+    metricReader: metricReader,
+});
+sdk.start();
+let standardLogger = null;
+let standardTracer = null;
+const getStandardLogger = () => {
+    if (!standardLogger) {
+        const logger = loggerProvider.getLogger('sst-middleware-logger', '1.0.0');
+        standardLogger = new core_1.StandardLogger(logger, serviceName);
+    }
+    return standardLogger;
+};
+exports.getStandardLogger = getStandardLogger;
+const getStandardTracer = () => {
+    if (!standardTracer) {
+        const tracer = api_1.trace.getTracer(serviceName, '1.0.0');
+        standardTracer = new core_1.StandardTracer(tracer, serviceName);
+    }
+    return standardTracer;
+};
+exports.getStandardTracer = getStandardTracer;
+const forceFlush = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield metricReader.forceFlush();
+    yield traceExporter.forceFlush();
+    yield loggerProvider.forceFlush();
+});
+exports.forceFlush = forceFlush;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/telemetry/core/__tests__/logger-types.test.d.ts

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

package/dist/telemetry/core/__tests__/logger-types.test.js

@@ -0,0 +1,325 @@
+"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");
+(0, vitest_1.describe)('Types - StandardLogData', () => {
+    (0, vitest_1.it)('deve aceitar log mínimo válido', () => {
+        const minimalLog = {
+            severity: 'INFO',
+            message: 'Test message',
+            serviceName: 'test-service',
+            environment: 'test',
+            timestamp: new Date().toISOString(),
+        };
+        (0, vitest_1.expect)(minimalLog).toBeDefined();
+        (0, vitest_1.expect)(minimalLog.severity).toBe('INFO');
+    });
+    (0, vitest_1.it)('deve aceitar todos os níveis de severity', () => {
+        const severities = [
+            'ERROR',
+            'WARN',
+            'INFO',
+            'DEBUG',
+        ];
+        severities.forEach((severity) => {
+            const log = {
+                severity,
+                message: 'Test',
+                serviceName: 'test',
+                environment: 'test',
+                timestamp: new Date().toISOString(),
+            };
+            (0, vitest_1.expect)(log.severity).toBe(severity);
+        });
+    });
+    (0, vitest_1.it)('deve aceitar log completo com todos os campos opcionais', () => {
+        const completeLog = {
+            severity: 'ERROR',
+            message: 'Complete log message',
+            error: new Error('Test error'),
+            serviceName: 'complete-service',
+            environment: 'production',
+            http: {
+                method: 'POST',
+                url: 'https://api.example.com/test',
+                endpoint: '/test',
+                statusCode: 500,
+                headers: { 'content-type': 'application/json' },
+                body: { test: 'data' },
+                params: { id: '123' },
+                query: { filter: 'active' },
+            },
+            user: {
+                accountUserUid: 'user-123',
+                accountUid: 'account-456',
+                applicationUid: 'app-789',
+            },
+            execution: {
+                requestId: 'req-abc',
+                awsRequestId: 'aws-xyz',
+                functionName: 'testFunction',
+                invocationId: 'inv-123',
+                controller: 'TestController',
+                controllerMethod: 'testMethod',
+                origin: 'mobile',
+            },
+            performance: {
+                durationMs: 1500,
+                success: false,
+            },
+            context: {
+                customField: 'customValue',
+                nested: {
+                    data: 123,
+                },
+            },
+            timestamp: new Date().toISOString(),
+        };
+        (0, vitest_1.expect)(completeLog).toBeDefined();
+        (0, vitest_1.expect)(completeLog.http).toBeDefined();
+        (0, vitest_1.expect)(completeLog.user).toBeDefined();
+        (0, vitest_1.expect)(completeLog.execution).toBeDefined();
+        (0, vitest_1.expect)(completeLog.performance).toBeDefined();
+        (0, vitest_1.expect)(completeLog.context).toBeDefined();
+    });
+    (0, vitest_1.it)('deve aceitar campos HTTP parciais', () => {
+        var _a, _b, _c;
+        const partialHttpLog = {
+            severity: 'INFO',
+            message: 'Partial HTTP',
+            serviceName: 'test',
+            environment: 'test',
+            http: {
+                method: 'GET',
+                endpoint: '/api/users',
+            },
+            timestamp: new Date().toISOString(),
+        };
+        (0, vitest_1.expect)((_a = partialHttpLog.http) === null || _a === void 0 ? void 0 : _a.method).toBe('GET');
+        (0, vitest_1.expect)((_b = partialHttpLog.http) === null || _b === void 0 ? void 0 : _b.endpoint).toBe('/api/users');
+        (0, vitest_1.expect)((_c = partialHttpLog.http) === null || _c === void 0 ? void 0 : _c.url).toBeUndefined();
+    });
+    (0, vitest_1.it)('deve aceitar campos de usuário parciais', () => {
+        var _a, _b;
+        const partialUserLog = {
+            severity: 'INFO',
+            message: 'Partial user',
+            serviceName: 'test',
+            environment: 'test',
+            user: {
+                accountUserUid: 'user-123',
+            },
+            timestamp: new Date().toISOString(),
+        };
+        (0, vitest_1.expect)((_a = partialUserLog.user) === null || _a === void 0 ? void 0 : _a.accountUserUid).toBe('user-123');
+        (0, vitest_1.expect)((_b = partialUserLog.user) === null || _b === void 0 ? void 0 : _b.accountUid).toBeUndefined();
+    });
+    (0, vitest_1.it)('deve aceitar campos de execução parciais', () => {
+        var _a, _b, _c;
+        const partialExecLog = {
+            severity: 'DEBUG',
+            message: 'Partial execution',
+            serviceName: 'test',
+            environment: 'test',
+            execution: {
+                requestId: 'req-123',
+                controller: 'TestController',
+            },
+            timestamp: new Date().toISOString(),
+        };
+        (0, vitest_1.expect)((_a = partialExecLog.execution) === null || _a === void 0 ? void 0 : _a.requestId).toBe('req-123');
+        (0, vitest_1.expect)((_b = partialExecLog.execution) === null || _b === void 0 ? void 0 : _b.controller).toBe('TestController');
+        (0, vitest_1.expect)((_c = partialExecLog.execution) === null || _c === void 0 ? void 0 : _c.awsRequestId).toBeUndefined();
+    });
+    (0, vitest_1.it)('deve aceitar performance com apenas durationMs', () => {
+        var _a, _b;
+        const durationOnlyLog = {
+            severity: 'INFO',
+            message: 'Duration only',
+            serviceName: 'test',
+            environment: 'test',
+            performance: {
+                durationMs: 500,
+            },
+            timestamp: new Date().toISOString(),
+        };
+        (0, vitest_1.expect)((_a = durationOnlyLog.performance) === null || _a === void 0 ? void 0 : _a.durationMs).toBe(500);
+        (0, vitest_1.expect)((_b = durationOnlyLog.performance) === null || _b === void 0 ? void 0 : _b.success).toBeUndefined();
+    });
+    (0, vitest_1.it)('deve aceitar performance com apenas success', () => {
+        var _a, _b;
+        const successOnlyLog = {
+            severity: 'INFO',
+            message: 'Success only',
+            serviceName: 'test',
+            environment: 'test',
+            performance: {
+                success: true,
+            },
+            timestamp: new Date().toISOString(),
+        };
+        (0, vitest_1.expect)((_a = successOnlyLog.performance) === null || _a === void 0 ? void 0 : _a.success).toBe(true);
+        (0, vitest_1.expect)((_b = successOnlyLog.performance) === null || _b === void 0 ? void 0 : _b.durationMs).toBeUndefined();
+    });
+    (0, vitest_1.it)('deve aceitar contexto com estruturas aninhadas complexas', () => {
+        var _a, _b;
+        const complexContextLog = {
+            severity: 'ERROR',
+            message: 'Complex context',
+            serviceName: 'test',
+            environment: 'test',
+            context: {
+                level1: {
+                    level2: {
+                        level3: {
+                            value: 'deep',
+                            array: [1, 2, 3],
+                        },
+                    },
+                },
+                simpleValue: 'test',
+                numericValue: 123,
+                booleanValue: true,
+            },
+            timestamp: new Date().toISOString(),
+        };
+        (0, vitest_1.expect)((_a = complexContextLog.context) === null || _a === void 0 ? void 0 : _a.level1).toBeDefined();
+        (0, vitest_1.expect)((_b = complexContextLog.context) === null || _b === void 0 ? void 0 : _b.simpleValue).toBe('test');
+    });
+});
+(0, vitest_1.describe)('Types - IStandardLogger', () => {
+    (0, vitest_1.it)('deve definir interface com os 4 métodos de log', () => {
+        const mockLogger = {
+            logError: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            logInfo: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            logWarn: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            logDebug: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        };
+        (0, vitest_1.expect)(mockLogger.logError).toBeDefined();
+        (0, vitest_1.expect)(mockLogger.logInfo).toBeDefined();
+        (0, vitest_1.expect)(mockLogger.logWarn).toBeDefined();
+        (0, vitest_1.expect)(mockLogger.logDebug).toBeDefined();
+    });
+    (0, vitest_1.it)('deve aceitar dados sem severity e timestamp nos métodos', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockLogger = {
+            logError: (data) => __awaiter(void 0, void 0, void 0, function* () {
+                (0, vitest_1.expect)(data.message).toBe('Error message');
+                (0, vitest_1.expect)(data.serviceName).toBe('test');
+                (0, vitest_1.expect)(data.severity).toBeUndefined();
+                (0, vitest_1.expect)(data.timestamp).toBeUndefined();
+            }),
+            logInfo: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            logWarn: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            logDebug: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        };
+        yield mockLogger.logError({
+            message: 'Error message',
+            serviceName: 'test',
+            environment: 'test',
+        });
+    }));
+});
+(0, vitest_1.describe)('Types - Validação de campos', () => {
+    (0, vitest_1.describe)('severity', () => {
+        (0, vitest_1.it)('deve aceitar apenas valores válidos', () => {
+            const validSeverities = ['ERROR', 'WARN', 'INFO', 'DEBUG'];
+            validSeverities.forEach((severity) => {
+                const log = {
+                    severity,
+                    message: 'test',
+                    serviceName: 'test',
+                    environment: 'test',
+                    timestamp: new Date().toISOString(),
+                };
+                (0, vitest_1.expect)(log.severity).toBe(severity);
+            });
+        });
+    });
+    (0, vitest_1.describe)('environment', () => {
+        (0, vitest_1.it)('deve aceitar ambientes comuns', () => {
+            const environments = ['development', 'staging', 'production', 'test'];
+            environments.forEach((env) => {
+                const log = {
+                    severity: 'INFO',
+                    message: 'test',
+                    serviceName: 'test',
+                    environment: env,
+                    timestamp: new Date().toISOString(),
+                };
+                (0, vitest_1.expect)(log.environment).toBe(env);
+            });
+        });
+    });
+    (0, vitest_1.describe)('timestamp', () => {
+        (0, vitest_1.it)('deve aceitar formato ISO 8601', () => {
+            const isoTimestamp = new Date().toISOString();
+            const log = {
+                severity: 'INFO',
+                message: 'test',
+                serviceName: 'test',
+                environment: 'test',
+                timestamp: isoTimestamp,
+            };
+            (0, vitest_1.expect)(log.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+        });
+    });
+    (0, vitest_1.describe)('http.statusCode', () => {
+        (0, vitest_1.it)('deve aceitar códigos HTTP válidos', () => {
+            const statusCodes = [200, 201, 400, 401, 404, 500, 502, 503];
+            statusCodes.forEach((statusCode) => {
+                var _a;
+                const log = {
+                    severity: 'INFO',
+                    message: 'test',
+                    serviceName: 'test',
+                    environment: 'test',
+                    http: { statusCode },
+                    timestamp: new Date().toISOString(),
+                };
+                (0, vitest_1.expect)((_a = log.http) === null || _a === void 0 ? void 0 : _a.statusCode).toBe(statusCode);
+            });
+        });
+    });
+    (0, vitest_1.describe)('performance.durationMs', () => {
+        (0, vitest_1.it)('deve aceitar valores numéricos positivos', () => {
+            const durations = [0, 100, 500, 1000, 5000, 10000];
+            durations.forEach((durationMs) => {
+                var _a;
+                const log = {
+                    severity: 'INFO',
+                    message: 'test',
+                    serviceName: 'test',
+                    environment: 'test',
+                    performance: { durationMs },
+                    timestamp: new Date().toISOString(),
+                };
+                (0, vitest_1.expect)((_a = log.performance) === null || _a === void 0 ? void 0 : _a.durationMs).toBe(durationMs);
+            });
+        });
+    });
+    (0, vitest_1.describe)('performance.success', () => {
+        (0, vitest_1.it)('deve aceitar valores booleanos', () => {
+            [true, false].forEach((success) => {
+                var _a;
+                const log = {
+                    severity: 'INFO',
+                    message: 'test',
+                    serviceName: 'test',
+                    environment: 'test',
+                    performance: { success },
+                    timestamp: new Date().toISOString(),
+                };
+                (0, vitest_1.expect)((_a = log.performance) === null || _a === void 0 ? void 0 : _a.success).toBe(success);
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger-types.test.js","sourceRoot":"","sources":["../../../../src/telemetry/core/__tests__/logger-types.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, it, expect } from 'vitest';\r\nimport type { StandardLogData, IStandardLogger } from '../logger-types';\r\n\r\ndescribe('Types - StandardLogData', () => {\r\n  it('deve aceitar log mínimo válido', () => {\r\n    const minimalLog: StandardLogData = {\r\n      severity: 'INFO',\r\n      message: 'Test message',\r\n      serviceName: 'test-service',\r\n      environment: 'test',\r\n      timestamp: new Date().toISOString(),\r\n    };\r\n\r\n    expect(minimalLog).toBeDefined();\r\n    expect(minimalLog.severity).toBe('INFO');\r\n  });\r\n\r\n  it('deve aceitar todos os níveis de severity', () => {\r\n    const severities: StandardLogData['severity'][] = [\r\n      'ERROR',\r\n      'WARN',\r\n      'INFO',\r\n      'DEBUG',\r\n    ];\r\n\r\n    severities.forEach((severity) => {\r\n      const log: StandardLogData = {\r\n        severity,\r\n        message: 'Test',\r\n        serviceName: 'test',\r\n        environment: 'test',\r\n        timestamp: new Date().toISOString(),\r\n      };\r\n      expect(log.severity).toBe(severity);\r\n    });\r\n  });\r\n\r\n  it('deve aceitar log completo com todos os campos opcionais', () => {\r\n    const completeLog: StandardLogData = {\r\n      severity: 'ERROR',\r\n      message: 'Complete log message',\r\n      error: new Error('Test error'),\r\n      serviceName: 'complete-service',\r\n      environment: 'production',\r\n      http: {\r\n        method: 'POST',\r\n        url: 'https://api.example.com/test',\r\n        endpoint: '/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      user: {\r\n        accountUserUid: 'user-123',\r\n        accountUid: 'account-456',\r\n        applicationUid: 'app-789',\r\n      },\r\n      execution: {\r\n        requestId: 'req-abc',\r\n        awsRequestId: 'aws-xyz',\r\n        functionName: 'testFunction',\r\n        invocationId: 'inv-123',\r\n        controller: 'TestController',\r\n        controllerMethod: 'testMethod',\r\n        origin: 'mobile',\r\n      },\r\n      performance: {\r\n        durationMs: 1500,\r\n        success: false,\r\n      },\r\n      context: {\r\n        customField: 'customValue',\r\n        nested: {\r\n          data: 123,\r\n        },\r\n      },\r\n      timestamp: new Date().toISOString(),\r\n    };\r\n\r\n    expect(completeLog).toBeDefined();\r\n    expect(completeLog.http).toBeDefined();\r\n    expect(completeLog.user).toBeDefined();\r\n    expect(completeLog.execution).toBeDefined();\r\n    expect(completeLog.performance).toBeDefined();\r\n    expect(completeLog.context).toBeDefined();\r\n  });\r\n\r\n  it('deve aceitar campos HTTP parciais', () => {\r\n    const partialHttpLog: StandardLogData = {\r\n      severity: 'INFO',\r\n      message: 'Partial HTTP',\r\n      serviceName: 'test',\r\n      environment: 'test',\r\n      http: {\r\n        method: 'GET',\r\n        endpoint: '/api/users',\r\n        // outros campos opcionais omitidos\r\n      },\r\n      timestamp: new Date().toISOString(),\r\n    };\r\n\r\n    expect(partialHttpLog.http?.method).toBe('GET');\r\n    expect(partialHttpLog.http?.endpoint).toBe('/api/users');\r\n    expect(partialHttpLog.http?.url).toBeUndefined();\r\n  });\r\n\r\n  it('deve aceitar campos de usuário parciais', () => {\r\n    const partialUserLog: StandardLogData = {\r\n      severity: 'INFO',\r\n      message: 'Partial user',\r\n      serviceName: 'test',\r\n      environment: 'test',\r\n      user: {\r\n        accountUserUid: 'user-123',\r\n        // outros campos opcionais omitidos\r\n      },\r\n      timestamp: new Date().toISOString(),\r\n    };\r\n\r\n    expect(partialUserLog.user?.accountUserUid).toBe('user-123');\r\n    expect(partialUserLog.user?.accountUid).toBeUndefined();\r\n  });\r\n\r\n  it('deve aceitar campos de execução parciais', () => {\r\n    const partialExecLog: StandardLogData = {\r\n      severity: 'DEBUG',\r\n      message: 'Partial execution',\r\n      serviceName: 'test',\r\n      environment: 'test',\r\n      execution: {\r\n        requestId: 'req-123',\r\n        controller: 'TestController',\r\n        // outros campos opcionais omitidos\r\n      },\r\n      timestamp: new Date().toISOString(),\r\n    };\r\n\r\n    expect(partialExecLog.execution?.requestId).toBe('req-123');\r\n    expect(partialExecLog.execution?.controller).toBe('TestController');\r\n    expect(partialExecLog.execution?.awsRequestId).toBeUndefined();\r\n  });\r\n\r\n  it('deve aceitar performance com apenas durationMs', () => {\r\n    const durationOnlyLog: StandardLogData = {\r\n      severity: 'INFO',\r\n      message: 'Duration only',\r\n      serviceName: 'test',\r\n      environment: 'test',\r\n      performance: {\r\n        durationMs: 500,\r\n      },\r\n      timestamp: new Date().toISOString(),\r\n    };\r\n\r\n    expect(durationOnlyLog.performance?.durationMs).toBe(500);\r\n    expect(durationOnlyLog.performance?.success).toBeUndefined();\r\n  });\r\n\r\n  it('deve aceitar performance com apenas success', () => {\r\n    const successOnlyLog: StandardLogData = {\r\n      severity: 'INFO',\r\n      message: 'Success only',\r\n      serviceName: 'test',\r\n      environment: 'test',\r\n      performance: {\r\n        success: true,\r\n      },\r\n      timestamp: new Date().toISOString(),\r\n    };\r\n\r\n    expect(successOnlyLog.performance?.success).toBe(true);\r\n    expect(successOnlyLog.performance?.durationMs).toBeUndefined();\r\n  });\r\n\r\n  it('deve aceitar contexto com estruturas aninhadas complexas', () => {\r\n    const complexContextLog: StandardLogData = {\r\n      severity: 'ERROR',\r\n      message: 'Complex context',\r\n      serviceName: 'test',\r\n      environment: 'test',\r\n      context: {\r\n        level1: {\r\n          level2: {\r\n            level3: {\r\n              value: 'deep',\r\n              array: [1, 2, 3],\r\n            },\r\n          },\r\n        },\r\n        simpleValue: 'test',\r\n        numericValue: 123,\r\n        booleanValue: true,\r\n      },\r\n      timestamp: new Date().toISOString(),\r\n    };\r\n\r\n    expect(complexContextLog.context?.level1).toBeDefined();\r\n    expect(complexContextLog.context?.simpleValue).toBe('test');\r\n  });\r\n});\r\n\r\ndescribe('Types - IStandardLogger', () => {\r\n  it('deve definir interface com os 4 métodos de log', () => {\r\n    // Este é um teste de tipo, só para garantir que a interface está correta\r\n    const mockLogger: IStandardLogger = {\r\n      logError: async () => {},\r\n      logInfo: async () => {},\r\n      logWarn: async () => {},\r\n      logDebug: async () => {},\r\n    };\r\n\r\n    expect(mockLogger.logError).toBeDefined();\r\n    expect(mockLogger.logInfo).toBeDefined();\r\n    expect(mockLogger.logWarn).toBeDefined();\r\n    expect(mockLogger.logDebug).toBeDefined();\r\n  });\r\n\r\n  it('deve aceitar dados sem severity e timestamp nos métodos', async () => {\r\n    const mockLogger: IStandardLogger = {\r\n      logError: async (data) => {\r\n        expect(data.message).toBe('Error message');\r\n        expect(data.serviceName).toBe('test');\r\n        // @ts-expect-error - severity não deve existir\r\n        expect(data.severity).toBeUndefined();\r\n        // @ts-expect-error - timestamp não deve existir\r\n        expect(data.timestamp).toBeUndefined();\r\n      },\r\n      logInfo: async () => {},\r\n      logWarn: async () => {},\r\n      logDebug: async () => {},\r\n    };\r\n\r\n    await mockLogger.logError({\r\n      message: 'Error message',\r\n      serviceName: 'test',\r\n      environment: 'test',\r\n    });\r\n  });\r\n});\r\n\r\ndescribe('Types - Validação de campos', () => {\r\n  describe('severity', () => {\r\n    it('deve aceitar apenas valores válidos', () => {\r\n      const validSeverities = ['ERROR', 'WARN', 'INFO', 'DEBUG'] as const;\r\n\r\n      validSeverities.forEach((severity) => {\r\n        const log: StandardLogData = {\r\n          severity,\r\n          message: 'test',\r\n          serviceName: 'test',\r\n          environment: 'test',\r\n          timestamp: new Date().toISOString(),\r\n        };\r\n        expect(log.severity).toBe(severity);\r\n      });\r\n    });\r\n  });\r\n\r\n  describe('environment', () => {\r\n    it('deve aceitar ambientes comuns', () => {\r\n      const environments = ['development', 'staging', 'production', 'test'];\r\n\r\n      environments.forEach((env) => {\r\n        const log: StandardLogData = {\r\n          severity: 'INFO',\r\n          message: 'test',\r\n          serviceName: 'test',\r\n          environment: env,\r\n          timestamp: new Date().toISOString(),\r\n        };\r\n        expect(log.environment).toBe(env);\r\n      });\r\n    });\r\n  });\r\n\r\n  describe('timestamp', () => {\r\n    it('deve aceitar formato ISO 8601', () => {\r\n      const isoTimestamp = new Date().toISOString();\r\n      const log: StandardLogData = {\r\n        severity: 'INFO',\r\n        message: 'test',\r\n        serviceName: 'test',\r\n        environment: 'test',\r\n        timestamp: isoTimestamp,\r\n      };\r\n\r\n      expect(log.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\r\n  describe('http.statusCode', () => {\r\n    it('deve aceitar códigos HTTP válidos', () => {\r\n      const statusCodes = [200, 201, 400, 401, 404, 500, 502, 503];\r\n\r\n      statusCodes.forEach((statusCode) => {\r\n        const log: StandardLogData = {\r\n          severity: 'INFO',\r\n          message: 'test',\r\n          serviceName: 'test',\r\n          environment: 'test',\r\n          http: { statusCode },\r\n          timestamp: new Date().toISOString(),\r\n        };\r\n        expect(log.http?.statusCode).toBe(statusCode);\r\n      });\r\n    });\r\n  });\r\n\r\n  describe('performance.durationMs', () => {\r\n    it('deve aceitar valores numéricos positivos', () => {\r\n      const durations = [0, 100, 500, 1000, 5000, 10000];\r\n\r\n      durations.forEach((durationMs) => {\r\n        const log: StandardLogData = {\r\n          severity: 'INFO',\r\n          message: 'test',\r\n          serviceName: 'test',\r\n          environment: 'test',\r\n          performance: { durationMs },\r\n          timestamp: new Date().toISOString(),\r\n        };\r\n        expect(log.performance?.durationMs).toBe(durationMs);\r\n      });\r\n    });\r\n  });\r\n\r\n  describe('performance.success', () => {\r\n    it('deve aceitar valores booleanos', () => {\r\n      [true, false].forEach((success) => {\r\n        const log: StandardLogData = {\r\n          severity: 'INFO',\r\n          message: 'test',\r\n          serviceName: 'test',\r\n          environment: 'test',\r\n          performance: { success },\r\n          timestamp: new Date().toISOString(),\r\n        };\r\n        expect(log.performance?.success).toBe(success);\r\n      });\r\n    });\r\n  });\r\n});\r\n"]}

package/dist/telemetry/core/__tests__/logger.test.d.ts

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