@mecanizou/telemetry-hub 1.0.0 → 1.0.1

package/dist/telemetry/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/tsed/__tests__/config.test.d.ts

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

package/dist/telemetry/tsed/__tests__/config.test.js

@@ -0,0 +1,146 @@
+"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 config_1 = require("../config");
+(0, vitest_1.describe)('TsedTelemetryProvider', () => {
+    let provider;
+    (0, vitest_1.beforeEach)(() => {
+        process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'https://test.com';
+        process.env.OTEL_EXPORTER_OTLP_USER = 'test-user';
+        process.env.OTEL_EXPORTER_OTLP_PASS = 'test-pass';
+        process.env.SERVICE_NAME = 'test-service';
+        process.env.STAGE = 'test';
+        provider = new config_1.TsedTelemetryProvider();
+    });
+    (0, vitest_1.describe)('initialize', () => {
+        (0, vitest_1.it)('deve inicializar com configuração válida', () => {
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+                serviceVersion: '1.0.0',
+                enabled: true,
+            });
+            (0, vitest_1.expect)(provider.isInitialized()).toBe(true);
+        });
+        (0, vitest_1.it)('não deve inicializar se já estiver inicializado', () => {
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+            });
+            const firstInit = provider.isInitialized();
+            provider.initialize({
+                endpoint: 'https://other.com',
+                username: 'other',
+                password: 'other',
+                serviceName: 'other-service',
+            });
+            (0, vitest_1.expect)(provider.isInitialized()).toBe(firstInit);
+        });
+        (0, vitest_1.it)('não deve inicializar se enabled=false', () => {
+            delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+            const newProvider = new config_1.TsedTelemetryProvider();
+            newProvider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                enabled: false,
+            });
+            (0, vitest_1.expect)(newProvider.isInitialized()).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('getLoggerProvider', () => {
+        (0, vitest_1.it)('deve retornar LoggerProvider após inicialização', () => {
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+            });
+            const loggerProvider = provider.getLoggerProvider();
+            (0, vitest_1.expect)(loggerProvider).toBeDefined();
+        });
+        (0, vitest_1.it)('deve retornar null se não inicializado', () => {
+            const newProvider = new config_1.TsedTelemetryProvider();
+            delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+            const emptyProvider = new config_1.TsedTelemetryProvider();
+            (0, vitest_1.expect)(emptyProvider.getLoggerProvider()).toBeNull();
+        });
+    });
+    (0, vitest_1.describe)('getTracerProvider', () => {
+        (0, vitest_1.it)('deve retornar TracerProvider após inicialização', () => {
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+            });
+            const tracerProvider = provider.getTracerProvider();
+            (0, vitest_1.expect)(tracerProvider).toBeDefined();
+        });
+    });
+    (0, vitest_1.describe)('getMeterProvider', () => {
+        (0, vitest_1.it)('deve retornar MeterProvider após inicialização', () => {
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+            });
+            const meterProvider = provider.getMeterProvider();
+            (0, vitest_1.expect)(meterProvider).toBeDefined();
+        });
+    });
+    (0, vitest_1.describe)('forceFlush', () => {
+        (0, vitest_1.it)('deve executar forceFlush sem erros', () => __awaiter(void 0, void 0, void 0, function* () {
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+            });
+            yield (0, vitest_1.expect)(provider.forceFlush()).resolves.not.toThrow();
+        }));
+    });
+    (0, vitest_1.describe)('shutdown', () => {
+        (0, vitest_1.it)('deve fazer shutdown e marcar como não inicializado', () => __awaiter(void 0, void 0, void 0, function* () {
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+            });
+            (0, vitest_1.expect)(provider.isInitialized()).toBe(true);
+            yield provider.shutdown();
+            (0, vitest_1.expect)(provider.isInitialized()).toBe(false);
+        }));
+    });
+    (0, vitest_1.describe)('integração completa', () => {
+        (0, vitest_1.it)('deve criar provider completo com logs, traces e métricas', () => {
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+                serviceVersion: '2.0.0',
+            });
+            (0, vitest_1.expect)(provider.isInitialized()).toBe(true);
+            (0, vitest_1.expect)(provider.getLoggerProvider()).toBeDefined();
+            (0, vitest_1.expect)(provider.getTracerProvider()).toBeDefined();
+            (0, vitest_1.expect)(provider.getMeterProvider()).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.test.js","sourceRoot":"","sources":["../../../../src/telemetry/tsed/__tests__/config.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, it, expect, vi, beforeEach } from 'vitest';\r\nimport { TsedTelemetryProvider } from '../config';\r\n\r\ndescribe('TsedTelemetryProvider', () => {\r\n  let provider: TsedTelemetryProvider;\r\n\r\n  beforeEach(() => {\r\n    // Mock das variáveis de ambiente\r\n    process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'https://test.com';\r\n    process.env.OTEL_EXPORTER_OTLP_USER = 'test-user';\r\n    process.env.OTEL_EXPORTER_OTLP_PASS = 'test-pass';\r\n    process.env.SERVICE_NAME = 'test-service';\r\n    process.env.STAGE = 'test';\r\n\r\n    provider = new TsedTelemetryProvider();\r\n  });\r\n\r\n  describe('initialize', () => {\r\n    it('deve inicializar com configuração válida', () => {\r\n      provider.initialize({\r\n        endpoint: 'https://test.com',\r\n        username: 'user',\r\n        password: 'pass',\r\n        serviceName: 'test-service',\r\n        serviceVersion: '1.0.0',\r\n        enabled: true,\r\n      });\r\n\r\n      expect(provider.isInitialized()).toBe(true);\r\n    });\r\n\r\n    it('não deve inicializar se já estiver inicializado', () => {\r\n      provider.initialize({\r\n        endpoint: 'https://test.com',\r\n        username: 'user',\r\n        password: 'pass',\r\n        serviceName: 'test-service',\r\n      });\r\n\r\n      const firstInit = provider.isInitialized();\r\n\r\n      provider.initialize({\r\n        endpoint: 'https://other.com',\r\n        username: 'other',\r\n        password: 'other',\r\n        serviceName: 'other-service',\r\n      });\r\n\r\n      expect(provider.isInitialized()).toBe(firstInit);\r\n    });\r\n\r\n    it('não deve inicializar se enabled=false', () => {\r\n      // Criar provider sem env vars para não auto-inicializar\r\n      delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;\r\n      const newProvider = new TsedTelemetryProvider();\r\n\r\n      newProvider.initialize({\r\n        endpoint: 'https://test.com',\r\n        username: 'user',\r\n        password: 'pass',\r\n        enabled: false,\r\n      });\r\n\r\n      expect(newProvider.isInitialized()).toBe(false);\r\n    });\r\n  });\r\n\r\n  describe('getLoggerProvider', () => {\r\n    it('deve retornar LoggerProvider após inicialização', () => {\r\n      provider.initialize({\r\n        endpoint: 'https://test.com',\r\n        username: 'user',\r\n        password: 'pass',\r\n        serviceName: 'test-service',\r\n      });\r\n\r\n      const loggerProvider = provider.getLoggerProvider();\r\n      expect(loggerProvider).toBeDefined();\r\n    });\r\n\r\n    it('deve retornar null se não inicializado', () => {\r\n      const newProvider = new TsedTelemetryProvider();\r\n      // Limpar env vars para não auto-inicializar\r\n      delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;\r\n\r\n      const emptyProvider = new TsedTelemetryProvider();\r\n      expect(emptyProvider.getLoggerProvider()).toBeNull();\r\n    });\r\n  });\r\n\r\n  describe('getTracerProvider', () => {\r\n    it('deve retornar TracerProvider após inicialização', () => {\r\n      provider.initialize({\r\n        endpoint: 'https://test.com',\r\n        username: 'user',\r\n        password: 'pass',\r\n        serviceName: 'test-service',\r\n      });\r\n\r\n      const tracerProvider = provider.getTracerProvider();\r\n      expect(tracerProvider).toBeDefined();\r\n    });\r\n  });\r\n\r\n  describe('getMeterProvider', () => {\r\n    it('deve retornar MeterProvider após inicialização', () => {\r\n      provider.initialize({\r\n        endpoint: 'https://test.com',\r\n        username: 'user',\r\n        password: 'pass',\r\n        serviceName: 'test-service',\r\n      });\r\n\r\n      const meterProvider = provider.getMeterProvider();\r\n      expect(meterProvider).toBeDefined();\r\n    });\r\n  });\r\n\r\n  describe('forceFlush', () => {\r\n    it('deve executar forceFlush sem erros', async () => {\r\n      provider.initialize({\r\n        endpoint: 'https://test.com',\r\n        username: 'user',\r\n        password: 'pass',\r\n        serviceName: 'test-service',\r\n      });\r\n\r\n      await expect(provider.forceFlush()).resolves.not.toThrow();\r\n    });\r\n  });\r\n\r\n  describe('shutdown', () => {\r\n    it('deve fazer shutdown e marcar como não inicializado', async () => {\r\n      provider.initialize({\r\n        endpoint: 'https://test.com',\r\n        username: 'user',\r\n        password: 'pass',\r\n        serviceName: 'test-service',\r\n      });\r\n\r\n      expect(provider.isInitialized()).toBe(true);\r\n\r\n      await provider.shutdown();\r\n\r\n      expect(provider.isInitialized()).toBe(false);\r\n    });\r\n  });\r\n\r\n  describe('integração completa', () => {\r\n    it('deve criar provider completo com logs, traces e métricas', () => {\r\n      provider.initialize({\r\n        endpoint: 'https://test.com',\r\n        username: 'user',\r\n        password: 'pass',\r\n        serviceName: 'test-service',\r\n        serviceVersion: '2.0.0',\r\n      });\r\n\r\n      expect(provider.isInitialized()).toBe(true);\r\n      expect(provider.getLoggerProvider()).toBeDefined();\r\n      expect(provider.getTracerProvider()).toBeDefined();\r\n      expect(provider.getMeterProvider()).toBeDefined();\r\n    });\r\n  });\r\n});\r\n"]}

package/dist/telemetry/tsed/__tests__/service.test.d.ts

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

package/dist/telemetry/tsed/__tests__/service.test.js

@@ -0,0 +1,63 @@
+"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 config_1 = require("../config");
+(0, vitest_1.describe)('TsedTelemetryService', () => {
+    let mockProvider;
+    (0, vitest_1.beforeEach)(() => {
+        mockProvider = {
+            isInitialized: vitest_1.vi.fn().mockReturnValue(true),
+            getLoggerProvider: vitest_1.vi.fn().mockReturnValue({
+                getLogger: vitest_1.vi.fn().mockReturnValue({
+                    emit: vitest_1.vi.fn(),
+                }),
+            }),
+            getTracerProvider: vitest_1.vi.fn().mockReturnValue({}),
+            forceFlush: vitest_1.vi.fn().mockResolvedValue(undefined),
+        };
+        process.env.SERVICE_NAME = 'test-service';
+        process.env.STAGE = 'test';
+    });
+    (0, vitest_1.describe)('TsedTelemetryProvider integration', () => {
+        (0, vitest_1.it)('deve criar provider com logs, traces e métricas', () => {
+            const provider = new config_1.TsedTelemetryProvider();
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+            });
+            (0, vitest_1.expect)(provider.isInitialized()).toBe(true);
+            (0, vitest_1.expect)(provider.getLoggerProvider()).toBeDefined();
+            (0, vitest_1.expect)(provider.getTracerProvider()).toBeDefined();
+            (0, vitest_1.expect)(provider.getMeterProvider()).toBeDefined();
+        });
+        (0, vitest_1.it)('deve retornar null quando não inicializado', () => {
+            delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+            const provider = new config_1.TsedTelemetryProvider();
+            (0, vitest_1.expect)(provider.getLoggerProvider()).toBeNull();
+            (0, vitest_1.expect)(provider.getTracerProvider()).toBeNull();
+            (0, vitest_1.expect)(provider.getMeterProvider()).toBeNull();
+        });
+        (0, vitest_1.it)('deve fazer forceFlush de todos os providers', () => __awaiter(void 0, void 0, void 0, function* () {
+            const provider = new config_1.TsedTelemetryProvider();
+            provider.initialize({
+                endpoint: 'https://test.com',
+                username: 'user',
+                password: 'pass',
+                serviceName: 'test-service',
+            });
+            yield (0, vitest_1.expect)(provider.forceFlush()).resolves.not.toThrow();
+        }));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+import { LoggerProvider } from '@opentelemetry/sdk-logs';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { MeterProvider } from '@opentelemetry/sdk-metrics';
+export interface TsedTelemetryConfig {
+    endpoint: string;
+    username: string;
+    password: string;
+    serviceName?: string;
+    serviceVersion?: string;
+    enabled?: boolean;
+}
+export declare class TsedTelemetryProvider {
+    private loggerProvider;
+    private tracerProvider;
+    private meterProvider;
+    private initialized;
+    constructor();
+    initialize(config: TsedTelemetryConfig): void;
+    getLoggerProvider(): LoggerProvider | null;
+    getTracerProvider(): NodeTracerProvider | null;
+    getMeterProvider(): MeterProvider | null;
+    isInitialized(): boolean;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+    $onDestroy(): Promise<void>;
+}

package/dist/telemetry/tsed/config.js

@@ -0,0 +1,166 @@
+"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.TsedTelemetryProvider = void 0;
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+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 resources_1 = require("@opentelemetry/resources");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const sync_log_record_processor_1 = require("./sync-log-record-processor");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const api_1 = require("@opentelemetry/api");
+class TsedTelemetryProvider {
+    constructor() {
+        this.loggerProvider = null;
+        this.tracerProvider = null;
+        this.meterProvider = null;
+        this.initialized = false;
+        if (!this.initialized && process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+            const serviceName = process.env.SERVICE_NAME || 'unknown-service';
+            const serviceStage = process.env.STAGE;
+            this.initialize({
+                endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || '',
+                username: process.env.OTEL_EXPORTER_OTLP_USER || '',
+                password: process.env.OTEL_EXPORTER_OTLP_PASS || '',
+                serviceName: `${serviceName}-${serviceStage}`,
+                serviceVersion: process.env.npm_package_version || '1.0.0',
+                enabled: process.env.OTEL_ENABLED !== 'false',
+            });
+        }
+    }
+    initialize(config) {
+        if (this.initialized) {
+            return;
+        }
+        if (config.enabled === false) {
+            console.log('[Telemetry] OpenTelemetry is disabled');
+            return;
+        }
+        if (!config.endpoint || !config.username || !config.password) {
+            if (process.env.NODE_ENV !== 'test' &&
+                process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+                console.error('[Telemetry] Missing required configuration');
+            }
+            return;
+        }
+        try {
+            const resource = new resources_1.Resource({
+                [semantic_conventions_1.ATTR_SERVICE_NAME]: config.serviceName || 'unknown-service',
+                [semantic_conventions_1.ATTR_SERVICE_VERSION]: config.serviceVersion || '1.0.0',
+            });
+            const basicAuth = `Basic ${Buffer.from(`${config.username}:${config.password}`).toString('base64')}`;
+            const headers = {
+                Authorization: basicAuth,
+                'Content-Type': 'application/json',
+            };
+            const logExporter = new exporter_logs_otlp_http_1.OTLPLogExporter({
+                url: `${config.endpoint}/v1/logs`,
+                headers,
+                timeoutMillis: 5000,
+                concurrencyLimit: 1,
+            });
+            const traceExporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({
+                url: `${config.endpoint}/v1/traces`,
+                headers,
+            });
+            const metricExporter = new exporter_metrics_otlp_http_1.OTLPMetricExporter({
+                url: `${config.endpoint}/v1/metrics`,
+                headers,
+            });
+            const syncProcessor = new sync_log_record_processor_1.TsedSyncLogRecordProcessor(logExporter);
+            this.loggerProvider = new sdk_logs_1.LoggerProvider({
+                resource,
+            });
+            this.loggerProvider.addLogRecordProcessor(syncProcessor);
+            this.tracerProvider = new sdk_trace_node_1.NodeTracerProvider({
+                resource,
+            });
+            this.tracerProvider.addSpanProcessor(new sdk_trace_node_1.BatchSpanProcessor(traceExporter));
+            this.tracerProvider.register();
+            api_1.trace.setGlobalTracerProvider(this.tracerProvider);
+            const metricReader = new sdk_metrics_1.PeriodicExportingMetricReader({
+                exporter: metricExporter,
+                exportIntervalMillis: 1000,
+            });
+            this.meterProvider = new sdk_metrics_1.MeterProvider({
+                resource,
+                readers: [metricReader],
+            });
+            api_1.metrics.setGlobalMeterProvider(this.meterProvider);
+            this.initialized = true;
+            console.log('[Telemetry] OpenTelemetry initialized successfully');
+        }
+        catch (error) {
+            console.error('[Telemetry] Failed to initialize OpenTelemetry:', error);
+        }
+    }
+    getLoggerProvider() {
+        return this.loggerProvider;
+    }
+    getTracerProvider() {
+        return this.tracerProvider;
+    }
+    getMeterProvider() {
+        return this.meterProvider;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    forceFlush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const startTime = Date.now();
+                console.log('[Telemetry] Starting forceFlush...');
+                const promises = [];
+                if (this.loggerProvider) {
+                    promises.push(this.loggerProvider.forceFlush());
+                }
+                if (this.tracerProvider) {
+                    promises.push(this.tracerProvider.forceFlush());
+                }
+                if (this.meterProvider) {
+                    promises.push(this.meterProvider.forceFlush());
+                }
+                yield Promise.all(promises);
+                const duration = Date.now() - startTime;
+                console.log(`[Telemetry] forceFlush completed successfully in ${duration}ms`);
+            }
+            catch (error) {
+                console.error('[Telemetry] Failed to force flush telemetry:', error);
+                throw error;
+            }
+        });
+    }
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            if (this.loggerProvider) {
+                promises.push(this.loggerProvider.shutdown());
+            }
+            if (this.tracerProvider) {
+                promises.push(this.tracerProvider.shutdown());
+            }
+            if (this.meterProvider) {
+                promises.push(this.meterProvider.shutdown());
+            }
+            yield Promise.all(promises);
+            this.initialized = false;
+        });
+    }
+    $onDestroy() {
+        return this.shutdown();
+    }
+}
+exports.TsedTelemetryProvider = TsedTelemetryProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/telemetry/tsed/config.ts"],"names":[],"mappings":"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","sourcesContent":["import { LoggerProvider } from '@opentelemetry/sdk-logs';\r\nimport { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';\r\nimport { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';\r\nimport { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';\r\nimport { Resource } from '@opentelemetry/resources';\r\nimport {\r\n  ATTR_SERVICE_NAME,\r\n  ATTR_SERVICE_VERSION,\r\n} from '@opentelemetry/semantic-conventions';\r\nimport { TsedSyncLogRecordProcessor } from './sync-log-record-processor';\r\nimport {\r\n  NodeTracerProvider,\r\n  BatchSpanProcessor,\r\n} from '@opentelemetry/sdk-trace-node';\r\nimport {\r\n  MeterProvider,\r\n  PeriodicExportingMetricReader,\r\n} from '@opentelemetry/sdk-metrics';\r\nimport { trace, metrics } from '@opentelemetry/api';\r\n\r\nexport interface TsedTelemetryConfig {\r\n  endpoint: string;\r\n  username: string;\r\n  password: string;\r\n  serviceName?: string;\r\n  serviceVersion?: string;\r\n  enabled?: boolean;\r\n}\r\n\r\nexport class TsedTelemetryProvider {\r\n  private loggerProvider: LoggerProvider | null = null;\r\n  private tracerProvider: NodeTracerProvider | null = null;\r\n  private meterProvider: MeterProvider | null = null;\r\n  private initialized = false;\r\n\r\n  constructor() {\r\n    // Auto-initialize synchronously with environment variables\r\n    if (!this.initialized && process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {\r\n      const serviceName = process.env.SERVICE_NAME || 'unknown-service';\r\n      const serviceStage = process.env.STAGE;\r\n      this.initialize({\r\n        endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || '',\r\n        username: process.env.OTEL_EXPORTER_OTLP_USER || '',\r\n        password: process.env.OTEL_EXPORTER_OTLP_PASS || '',\r\n        serviceName: `${serviceName}-${serviceStage}`,\r\n        serviceVersion: process.env.npm_package_version || '1.0.0',\r\n        enabled: process.env.OTEL_ENABLED !== 'false',\r\n      });\r\n    }\r\n  }\r\n\r\n  public initialize(config: TsedTelemetryConfig): void {\r\n    if (this.initialized) {\r\n      return;\r\n    }\r\n\r\n    if (config.enabled === false) {\r\n      console.log('[Telemetry] OpenTelemetry is disabled');\r\n      return;\r\n    }\r\n\r\n    if (!config.endpoint || !config.username || !config.password) {\r\n      // Não logar erro se estivermos em modo de build\r\n      if (\r\n        process.env.NODE_ENV !== 'test' &&\r\n        process.env.OTEL_EXPORTER_OTLP_ENDPOINT\r\n      ) {\r\n        console.error('[Telemetry] Missing required configuration');\r\n      }\r\n      return;\r\n    }\r\n\r\n    try {\r\n      // Create resource with service information\r\n      const resource = new Resource({\r\n        [ATTR_SERVICE_NAME]: config.serviceName || 'unknown-service',\r\n        [ATTR_SERVICE_VERSION]: config.serviceVersion || '1.0.0',\r\n      });\r\n\r\n      const basicAuth = `Basic ${Buffer.from(`${config.username}:${config.password}`).toString('base64')}`;\r\n      const headers = {\r\n        Authorization: basicAuth,\r\n        'Content-Type': 'application/json',\r\n      };\r\n\r\n      // Create OTLP exporters with authentication and timeout configuration\r\n      const logExporter = new OTLPLogExporter({\r\n        url: `${config.endpoint}/v1/logs`,\r\n        headers,\r\n        timeoutMillis: 5000, // 5 second timeout for exports\r\n        concurrencyLimit: 1, // Process one export at a time\r\n      });\r\n\r\n      const traceExporter = new OTLPTraceExporter({\r\n        url: `${config.endpoint}/v1/traces`,\r\n        headers,\r\n      });\r\n\r\n      const metricExporter = new OTLPMetricExporter({\r\n        url: `${config.endpoint}/v1/metrics`,\r\n        headers,\r\n      });\r\n\r\n      // Use custom SyncLogRecordProcessor instead of SimpleLogRecordProcessor\r\n      // This ensures that the async HTTP export is properly awaited in Lambda\r\n      // environments where execution context freezes after handler returns\r\n      const syncProcessor = new TsedSyncLogRecordProcessor(logExporter);\r\n\r\n      // Create logger provider with resource and processors\r\n      this.loggerProvider = new LoggerProvider({\r\n        resource,\r\n      });\r\n\r\n      // Add processor after creation\r\n      this.loggerProvider.addLogRecordProcessor(syncProcessor);\r\n\r\n      // Create tracer provider\r\n      this.tracerProvider = new NodeTracerProvider({\r\n        resource,\r\n      });\r\n      this.tracerProvider.addSpanProcessor(\r\n        new BatchSpanProcessor(traceExporter)\r\n      );\r\n      this.tracerProvider.register();\r\n\r\n      // Set global tracer provider\r\n      trace.setGlobalTracerProvider(this.tracerProvider);\r\n\r\n      // Create meter provider\r\n      const metricReader = new PeriodicExportingMetricReader({\r\n        exporter: metricExporter,\r\n        exportIntervalMillis: 1000,\r\n      });\r\n\r\n      this.meterProvider = new MeterProvider({\r\n        resource,\r\n        readers: [metricReader],\r\n      });\r\n\r\n      // Set global meter provider\r\n      metrics.setGlobalMeterProvider(this.meterProvider);\r\n\r\n      this.initialized = true;\r\n      console.log('[Telemetry] OpenTelemetry initialized successfully');\r\n    } catch (error) {\r\n      console.error('[Telemetry] Failed to initialize OpenTelemetry:', error);\r\n    }\r\n  }\r\n\r\n  public getLoggerProvider(): LoggerProvider | null {\r\n    return this.loggerProvider;\r\n  }\r\n\r\n  public getTracerProvider(): NodeTracerProvider | null {\r\n    return this.tracerProvider;\r\n  }\r\n\r\n  public getMeterProvider(): MeterProvider | null {\r\n    return this.meterProvider;\r\n  }\r\n\r\n  public isInitialized(): boolean {\r\n    return this.initialized;\r\n  }\r\n\r\n  /**\r\n   * Force flush all pending logs, traces and metrics to ensure they are sent before Lambda freezes\r\n   * This is critical in AWS Lambda environments where execution context freezes\r\n   * immediately after the handler returns, potentially before async HTTP requests complete\r\n   */\r\n  public async forceFlush(): Promise<void> {\r\n    try {\r\n      const startTime = Date.now();\r\n      console.log('[Telemetry] Starting forceFlush...');\r\n\r\n      // Force flush all providers in parallel\r\n      const promises: Promise<void>[] = [];\r\n\r\n      if (this.loggerProvider) {\r\n        promises.push(this.loggerProvider.forceFlush());\r\n      }\r\n\r\n      if (this.tracerProvider) {\r\n        promises.push(this.tracerProvider.forceFlush());\r\n      }\r\n\r\n      if (this.meterProvider) {\r\n        promises.push(this.meterProvider.forceFlush());\r\n      }\r\n\r\n      await Promise.all(promises);\r\n\r\n      const duration = Date.now() - startTime;\r\n      console.log(\r\n        `[Telemetry] forceFlush completed successfully in ${duration}ms`\r\n      );\r\n    } catch (error) {\r\n      console.error('[Telemetry] Failed to force flush telemetry:', error);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  public async shutdown(): Promise<void> {\r\n    const promises: Promise<void>[] = [];\r\n\r\n    if (this.loggerProvider) {\r\n      promises.push(this.loggerProvider.shutdown());\r\n    }\r\n\r\n    if (this.tracerProvider) {\r\n      promises.push(this.tracerProvider.shutdown());\r\n    }\r\n\r\n    if (this.meterProvider) {\r\n      promises.push(this.meterProvider.shutdown());\r\n    }\r\n\r\n    await Promise.all(promises);\r\n    this.initialized = false;\r\n  }\r\n\r\n  $onDestroy(): Promise<void> {\r\n    return this.shutdown();\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,4 @@
+export * from './config';
+export * from './service';
+export * from './log-telemetry';
+export * from './sync-log-record-processor';

package/dist/telemetry/tsed/index.js

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

package/dist/telemetry/tsed/log-telemetry.d.ts

@@ -0,0 +1 @@
+export declare function TsedLogTelemetry(): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;