@mecanizou/telemetry-hub 1.0.0 → 1.0.2

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

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

package/dist/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/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/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/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/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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHNlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMkNBQXlCO0FBQ3pCLDRDQUEwQjtBQUMxQixrREFBZ0M7QUFDaEMsOERBQTRDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb25maWcnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xvZy10ZWxlbWV0cnknO1xyXG5leHBvcnQgKiBmcm9tICcuL3N5bmMtbG9nLXJlY29yZC1wcm9jZXNzb3InO1xyXG4iXX0=

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

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