@mecanizou/telemetry-hub 1.0.0 → 1.0.1

package/dist/tsed/config.d.ts

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

package/dist/tsed/config.js

@@ -0,0 +1,113 @@
+"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 resources_1 = require("@opentelemetry/resources");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const sync_log_record_processor_1 = require("./sync-log-record-processor");
+class TsedTelemetryProvider {
+    constructor() {
+        this.loggerProvider = 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 logExporter = new exporter_logs_otlp_http_1.OTLPLogExporter({
+                url: `${config.endpoint}/v1/logs`,
+                headers: {
+                    Authorization: `Basic ${Buffer.from(`${config.username}:${config.password}`).toString('base64')}`,
+                },
+                timeoutMillis: 5000,
+                concurrencyLimit: 1,
+            });
+            const syncProcessor = new sync_log_record_processor_1.TsedSyncLogRecordProcessor(logExporter);
+            this.loggerProvider = new sdk_logs_1.LoggerProvider({
+                resource,
+            });
+            this.loggerProvider.addLogRecordProcessor(syncProcessor);
+            this.initialized = true;
+            console.log('[Telemetry] OpenTelemetry initialized successfully');
+        }
+        catch (error) {
+            console.error('[Telemetry] Failed to initialize OpenTelemetry:', error);
+        }
+    }
+    getLoggerProvider() {
+        return this.loggerProvider;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    forceFlush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.loggerProvider) {
+                console.warn('[Telemetry] forceFlush called but loggerProvider is null');
+                return;
+            }
+            try {
+                const startTime = Date.now();
+                console.log('[Telemetry] Starting forceFlush...');
+                yield this.loggerProvider.forceFlush();
+                const duration = Date.now() - startTime;
+                console.log(`[Telemetry] forceFlush completed successfully in ${duration}ms`);
+            }
+            catch (error) {
+                console.error('[Telemetry] Failed to force flush logs:', error);
+                throw error;
+            }
+        });
+    }
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loggerProvider) {
+                yield this.loggerProvider.shutdown();
+                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 { 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\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 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      // Create OTLP exporter with authentication and timeout configuration\r\n      const logExporter = new OTLPLogExporter({\r\n        url: `${config.endpoint}/v1/logs`,\r\n        headers: {\r\n          Authorization: `Basic ${Buffer.from(`${config.username}:${config.password}`).toString('base64')}`,\r\n        },\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      // 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      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 isInitialized(): boolean {\r\n    return this.initialized;\r\n  }\r\n\r\n  /**\r\n   * Force flush all pending logs 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    if (!this.loggerProvider) {\r\n      console.warn('[Telemetry] forceFlush called but loggerProvider is null');\r\n      return;\r\n    }\r\n\r\n    try {\r\n      const startTime = Date.now();\r\n      console.log('[Telemetry] Starting forceFlush...');\r\n\r\n      // forceFlush ensures all pending logs are exported immediately\r\n      await this.loggerProvider.forceFlush();\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 logs:', error);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  public async shutdown(): Promise<void> {\r\n    if (this.loggerProvider) {\r\n      await this.loggerProvider.shutdown();\r\n      this.initialized = false;\r\n    }\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,3 @@
+export * from './config';
+export * from './service';
+export * from './log-telemetry';

package/dist/tsed/index.js

@@ -0,0 +1,20 @@
+"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);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVsZW1ldHJ5L3RzZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDJDQUF5QjtBQUN6Qiw0Q0FBMEI7QUFDMUIsa0RBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb25maWcnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xvZy10ZWxlbWV0cnknO1xyXG4iXX0=

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

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

package/dist/tsed/log-telemetry.js

@@ -0,0 +1,81 @@
+"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.TsedLogTelemetry = TsedLogTelemetry;
+const service_1 = require("./service");
+function TsedLogTelemetry() {
+    return function (_target, _propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const methodName = _propertyKey;
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f, _g;
+                const $ctx = args.find((arg) => (arg === null || arg === void 0 ? void 0 : arg.request) && (arg === null || arg === void 0 ? void 0 : arg.response));
+                let controllerName = 'UnknownController';
+                if (((_a = this === null || this === void 0 ? void 0 : this.constructor) === null || _a === void 0 ? void 0 : _a.name) && this.constructor.name !== 'Object') {
+                    controllerName = this.constructor.name;
+                }
+                if (!$ctx) {
+                    console.warn('[LogTelemetry] Context not found, executing without telemetry');
+                    return yield originalMethod.apply(this, args);
+                }
+                let telemetryService;
+                try {
+                    if ($ctx.injector) {
+                        telemetryService = $ctx.injector.get(service_1.TsedTelemetryService);
+                    }
+                }
+                catch (error) {
+                    (_b = $ctx.logger) === null || _b === void 0 ? void 0 : _b.warn({
+                        'LogTelemetry - Failed to get TelemetryService from injector': error,
+                    });
+                }
+                if (!telemetryService) {
+                    (_c = $ctx.logger) === null || _c === void 0 ? void 0 : _c.warn('[LogTelemetry] TelemetryService not available, executing without telemetry');
+                    return yield originalMethod.apply(this, args);
+                }
+                try {
+                    const result = yield originalMethod.apply(this, args);
+                    return result;
+                }
+                catch (error) {
+                    (_d = $ctx.logger) === null || _d === void 0 ? void 0 : _d.info('Error caught, sending to telemetry');
+                    const request = $ctx.request;
+                    let userInfo = {};
+                    try {
+                        if (typeof LoggedUserIdentifier !== 'undefined') {
+                            const { loggedUser } = LoggedUserIdentifier.use($ctx);
+                            userInfo = {
+                                accountUserUid: loggedUser === null || loggedUser === void 0 ? void 0 : loggedUser.uid,
+                                accountUid: (_e = loggedUser === null || loggedUser === void 0 ? void 0 : loggedUser.account) === null || _e === void 0 ? void 0 : _e.uid,
+                                applicationUid: (_f = loggedUser === null || loggedUser === void 0 ? void 0 : loggedUser.application) === null || _f === void 0 ? void 0 : _f.uid,
+                            };
+                        }
+                    }
+                    catch (e) {
+                    }
+                    yield telemetryService.logError(Object.assign(Object.assign({ error: error, context: {
+                            statusCode: error.status || 500,
+                            url: request.url,
+                            headers: request.headers,
+                            body: request.body,
+                            params: request.params,
+                            query: request.query,
+                        } }, userInfo), { requestId: $ctx.id, awsRequestId: (_g = $ctx.context) === null || _g === void 0 ? void 0 : _g.awsRequestId, endpoint: request.url, method: request.method, controller: controllerName, controllerMethod: methodName }));
+                    $ctx.logger.info('Error sent to telemetry');
+                    throw error;
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log-telemetry.js","sourceRoot":"","sources":["../../src/telemetry/tsed/log-telemetry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Decorator que captura erros automaticamente e envia para telemetria\r\n * Uso no controller:\r\n *\r\n * @LogTelemetry()\r\n * async getCheckout(@Context() $ctx: ServerlessContext, ...) {\r\n *   return await this.service.execute(params);\r\n * }\r\n */\r\nimport { ServerlessContext } from '@tsed/platform-serverless';\r\nimport { TsedTelemetryService } from './service';\r\n\r\nexport function TsedLogTelemetry() {\r\n  return function (\r\n    _target: any,\r\n    _propertyKey: string,\r\n    descriptor: PropertyDescriptor\r\n  ) {\r\n    const originalMethod = descriptor.value;\r\n    const methodName = _propertyKey;\r\n\r\n    descriptor.value = async function (this: any, ...args: any[]) {\r\n      // Encontrar o contexto\r\n      const $ctx: ServerlessContext = args.find(\r\n        (arg) => arg?.request && arg?.response\r\n      );\r\n\r\n      // Capturar o nome do controller - tentar várias fontes\r\n      let controllerName = 'UnknownController';\r\n\r\n      if (this?.constructor?.name && this.constructor.name !== 'Object') {\r\n        controllerName = this.constructor.name;\r\n      }\r\n\r\n      if (!$ctx) {\r\n        console.warn(\r\n          '[LogTelemetry] Context not found, executing without telemetry'\r\n        );\r\n        return await originalMethod.apply(this, args);\r\n      }\r\n\r\n      // Buscar o TelemetryService do InjectorService do contexto\r\n      let telemetryService: TsedTelemetryService | undefined;\r\n      try {\r\n        if ($ctx.injector) {\r\n          telemetryService = $ctx.injector.get(\r\n            TsedTelemetryService\r\n          ) as TsedTelemetryService;\r\n        }\r\n      } catch (error) {\r\n        $ctx.logger?.warn({\r\n          'LogTelemetry - Failed to get TelemetryService from injector': error,\r\n        });\r\n      }\r\n\r\n      if (!telemetryService) {\r\n        $ctx.logger?.warn(\r\n          '[LogTelemetry] TelemetryService not available, executing without telemetry'\r\n        );\r\n        return await originalMethod.apply(this, args);\r\n      }\r\n\r\n      try {\r\n        const result = await originalMethod.apply(this, args);\r\n        return result;\r\n      } catch (error: any) {\r\n        $ctx.logger?.info('Error caught, sending to telemetry');\r\n        // Extrair informações do usuário\r\n        const request = $ctx.request;\r\n\r\n        // Tentar extrair dados do usuário se disponível\r\n        // LoggedUserIdentifier deve ser fornecido pela aplicação\r\n        let userInfo: any = {};\r\n        try {\r\n          // @ts-ignore - LoggedUserIdentifier é específico da aplicação\r\n          if (typeof LoggedUserIdentifier !== 'undefined') {\r\n            // @ts-ignore\r\n            const { loggedUser } = LoggedUserIdentifier.use($ctx);\r\n            userInfo = {\r\n              accountUserUid: loggedUser?.uid,\r\n              accountUid: loggedUser?.account?.uid,\r\n              applicationUid: loggedUser?.application?.uid,\r\n            };\r\n          }\r\n        } catch (e) {\r\n          // LoggedUserIdentifier não está disponível, continuar sem user info\r\n        }\r\n\r\n        await telemetryService.logError({\r\n          error: error,\r\n          context: {\r\n            statusCode: error.status || 500,\r\n            url: request.url,\r\n            headers: request.headers,\r\n            body: request.body,\r\n            params: request.params,\r\n            query: request.query,\r\n          },\r\n          ...userInfo,\r\n          requestId: $ctx.id,\r\n          awsRequestId: $ctx.context?.awsRequestId,\r\n          endpoint: request.url,\r\n          method: request.method,\r\n          controller: controllerName,\r\n          controllerMethod: methodName,\r\n        });\r\n        $ctx.logger.info('Error sent to telemetry');\r\n\r\n        // Re-throw para manter o comportamento normal de erro\r\n        throw error;\r\n      }\r\n    };\r\n\r\n    return descriptor;\r\n  };\r\n}\r\n"]}

package/dist/tsed/service.d.ts

@@ -0,0 +1,24 @@
+import { ServerlessContext } from '@tsed/platform-serverless';
+import { TsedTelemetryProvider } from './config';
+export interface ErrorLogData {
+    error: Error;
+    context?: Record<string, any>;
+    accountUserUid?: string;
+    accountUid?: string;
+    requestId?: string;
+    endpoint?: string;
+    method?: string;
+    controller?: string;
+    controllerMethod?: string;
+    applicationUid?: string;
+    awsRequestId?: string;
+}
+export declare class TsedTelemetryService {
+    private readonly telemetryProvider;
+    protected $ctx: ServerlessContext;
+    private standardLogger;
+    constructor(telemetryProvider: TsedTelemetryProvider);
+    private getLogger;
+    logError(data: ErrorLogData): Promise<void>;
+    logException(error: Error, context?: Record<string, any>): Promise<void>;
+}

package/dist/tsed/service.js

@@ -0,0 +1,131 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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.TsedTelemetryService = void 0;
+const di_1 = require("@tsed/di");
+const platform_serverless_1 = require("@tsed/platform-serverless");
+const config_1 = require("./config");
+const core_1 = require("../core");
+let TsedTelemetryService = class TsedTelemetryService {
+    constructor(telemetryProvider) {
+        this.telemetryProvider = telemetryProvider;
+        this.standardLogger = null;
+    }
+    getLogger() {
+        var _a;
+        if (!this.telemetryProvider.isInitialized()) {
+            (_a = this.$ctx) === null || _a === void 0 ? void 0 : _a.logger.warn('[Telemetry] Telemetry not initialized, skipping log');
+            return null;
+        }
+        if (!this.standardLogger) {
+            const loggerProvider = this.telemetryProvider.getLoggerProvider();
+            if (!loggerProvider) {
+                return null;
+            }
+            const otelLogger = loggerProvider.getLogger('tsed-service-logger', '1.0.0');
+            const serviceName = process.env.SERVICE_NAME || 'tsed-service';
+            this.standardLogger = new core_1.StandardLogger(otelLogger, serviceName);
+        }
+        return this.standardLogger;
+    }
+    logError(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const logger = this.getLogger();
+            if (!logger) {
+                return;
+            }
+            try {
+                let stage = process.env.STAGE || 'development';
+                if (stage === 'prod')
+                    stage = 'production';
+                (_a = this.$ctx) === null || _a === void 0 ? void 0 : _a.logger.info('[Telemetry] Logging error...');
+                yield logger.logError({
+                    message: data.error.message,
+                    error: data.error,
+                    serviceName: process.env.SERVICE_NAME || 'tsed-service',
+                    environment: stage,
+                    http: {
+                        endpoint: data.endpoint,
+                        method: data.method,
+                        statusCode: data.error.status || 500,
+                    },
+                    user: {
+                        accountUserUid: data.accountUserUid,
+                        accountUid: data.accountUid,
+                        applicationUid: data.applicationUid,
+                    },
+                    execution: {
+                        requestId: data.requestId,
+                        awsRequestId: data.awsRequestId,
+                        controller: data.controller,
+                        controllerMethod: data.controllerMethod,
+                    },
+                    context: data.context,
+                });
+                (_b = this.$ctx) === null || _b === void 0 ? void 0 : _b.logger.info('[Telemetry] Forcing flush...');
+                const flushStartTime = Date.now();
+                yield this.telemetryProvider.forceFlush();
+                const flushDuration = Date.now() - flushStartTime;
+                (_c = this.$ctx) === null || _c === void 0 ? void 0 : _c.logger.info({
+                    'Telemetry - Log sent successfully': {
+                        errorType: data.error.name,
+                        message: data.error.message,
+                        endpoint: data.endpoint,
+                        controller: data.controller,
+                        method: data.controllerMethod,
+                        flushDurationMs: flushDuration,
+                    },
+                });
+            }
+            catch (error) {
+                (_d = this.$ctx) === null || _d === void 0 ? void 0 : _d.logger.error({
+                    'Telemetry - CRITICAL ERROR - Failed to log error': {
+                        originalError: data.error.message,
+                        telemetryError: error instanceof Error ? error.message : String(error),
+                        stack: error instanceof Error ? error.stack : undefined,
+                    },
+                });
+            }
+        });
+    }
+    logException(error, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.logError({
+                error,
+                context,
+            });
+        });
+    }
+};
+exports.TsedTelemetryService = TsedTelemetryService;
+__decorate([
+    (0, di_1.InjectContext)(),
+    __metadata("design:type", platform_serverless_1.ServerlessContext)
+], TsedTelemetryService.prototype, "$ctx", void 0);
+exports.TsedTelemetryService = TsedTelemetryService = __decorate([
+    (0, di_1.Injectable)(),
+    __param(0, (0, di_1.Inject)()),
+    __metadata("design:paramtypes", [config_1.TsedTelemetryProvider])
+], TsedTelemetryService);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../src/telemetry/tsed/service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, InjectContext } from '@tsed/di';\r\nimport { ServerlessContext } from '@tsed/platform-serverless';\r\nimport { TsedTelemetryProvider } from './config';\r\nimport { StandardLogger } from '../core';\r\n\r\nexport interface ErrorLogData {\r\n  error: Error;\r\n  context?: Record<string, any>;\r\n  accountUserUid?: string;\r\n  accountUid?: string;\r\n  requestId?: string;\r\n  endpoint?: string;\r\n  method?: string;\r\n  controller?: string;\r\n  controllerMethod?: string;\r\n  applicationUid?: string;\r\n  awsRequestId?: string;\r\n}\r\n\r\n@Injectable()\r\nexport class TsedTelemetryService {\r\n  @InjectContext() protected $ctx: ServerlessContext;\r\n  private standardLogger: StandardLogger | null = null;\r\n\r\n  constructor(\r\n    @Inject()\r\n    private readonly telemetryProvider: TsedTelemetryProvider\r\n  ) {}\r\n\r\n  private getLogger(): StandardLogger | null {\r\n    if (!this.telemetryProvider.isInitialized()) {\r\n      this.$ctx?.logger.warn(\r\n        '[Telemetry] Telemetry not initialized, skipping log'\r\n      );\r\n      return null;\r\n    }\r\n\r\n    if (!this.standardLogger) {\r\n      const loggerProvider = this.telemetryProvider.getLoggerProvider();\r\n      if (!loggerProvider) {\r\n        return null;\r\n      }\r\n\r\n      const otelLogger = loggerProvider.getLogger(\r\n        'tsed-service-logger',\r\n        '1.0.0'\r\n      );\r\n\r\n      // Pega o service name do ambiente ou usa default\r\n      const serviceName = process.env.SERVICE_NAME || 'tsed-service';\r\n      this.standardLogger = new StandardLogger(otelLogger, serviceName);\r\n    }\r\n\r\n    return this.standardLogger;\r\n  }\r\n\r\n  public async logError(data: ErrorLogData): Promise<void> {\r\n    const logger = this.getLogger();\r\n    if (!logger) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      let stage = process.env.STAGE || 'development';\r\n      if (stage === 'prod') stage = 'production';\r\n\r\n      this.$ctx?.logger.info('[Telemetry] Logging error...');\r\n\r\n      await logger.logError({\r\n        message: data.error.message,\r\n        error: data.error,\r\n        serviceName: process.env.SERVICE_NAME || 'tsed-service',\r\n        environment: stage,\r\n        http: {\r\n          endpoint: data.endpoint,\r\n          method: data.method,\r\n          statusCode: (data.error as any).status || 500,\r\n        },\r\n        user: {\r\n          accountUserUid: data.accountUserUid,\r\n          accountUid: data.accountUid,\r\n          applicationUid: data.applicationUid,\r\n        },\r\n        execution: {\r\n          requestId: data.requestId,\r\n          awsRequestId: data.awsRequestId,\r\n          controller: data.controller,\r\n          controllerMethod: data.controllerMethod,\r\n        },\r\n        context: data.context,\r\n      });\r\n\r\n      // CRITICAL: Force flush to ensure log is sent before Lambda freezes\r\n      this.$ctx?.logger.info('[Telemetry] Forcing flush...');\r\n      const flushStartTime = Date.now();\r\n\r\n      await this.telemetryProvider.forceFlush();\r\n\r\n      const flushDuration = Date.now() - flushStartTime;\r\n\r\n      this.$ctx?.logger.info({\r\n        'Telemetry - Log sent successfully': {\r\n          errorType: data.error.name,\r\n          message: data.error.message,\r\n          endpoint: data.endpoint,\r\n          controller: data.controller,\r\n          method: data.controllerMethod,\r\n          flushDurationMs: flushDuration,\r\n        },\r\n      });\r\n    } catch (error) {\r\n      this.$ctx?.logger.error({\r\n        'Telemetry - CRITICAL ERROR - Failed to log error': {\r\n          originalError: data.error.message,\r\n          telemetryError:\r\n            error instanceof Error ? error.message : String(error),\r\n          stack: error instanceof Error ? error.stack : undefined,\r\n        },\r\n      });\r\n      // Don't re-throw to avoid breaking the application flow\r\n    }\r\n  }\r\n\r\n  public async logException(\r\n    error: Error,\r\n    context?: Record<string, any>\r\n  ): Promise<void> {\r\n    await this.logError({\r\n      error,\r\n      context,\r\n    });\r\n  }\r\n}\r\n"]}

package/dist/tsed/sync-log-record-processor.d.ts

@@ -0,0 +1,11 @@
+import { LogRecordProcessor, ReadableLogRecord } from '@opentelemetry/sdk-logs';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { Context } from '@opentelemetry/api';
+export declare class TsedSyncLogRecordProcessor implements LogRecordProcessor {
+    private readonly exporter;
+    private readonly pendingExports;
+    constructor(exporter: OTLPLogExporter);
+    onEmit(logRecord: ReadableLogRecord, _context?: Context): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/tsed/sync-log-record-processor.js

@@ -0,0 +1,74 @@
+"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.TsedSyncLogRecordProcessor = void 0;
+class TsedSyncLogRecordProcessor {
+    constructor(exporter) {
+        this.pendingExports = [];
+        this.exporter = exporter;
+    }
+    onEmit(logRecord, _context) {
+        const exportPromise = new Promise((resolve, reject) => {
+            this.exporter.export([logRecord], (result) => {
+                if (result.code === 0) {
+                    resolve();
+                }
+                else {
+                    console.error('[SyncLogRecordProcessor] Export failed:', result.error);
+                    reject(result.error instanceof Error
+                        ? result.error
+                        : new Error(String(result.error)));
+                }
+            });
+        })
+            .then(() => {
+            const index = this.pendingExports.indexOf(exportPromise);
+            if (index > -1) {
+                this.pendingExports.splice(index, 1);
+            }
+        })
+            .catch((error) => {
+            console.error('[SyncLogRecordProcessor] Export error:', error);
+            const index = this.pendingExports.indexOf(exportPromise);
+            if (index > -1) {
+                this.pendingExports.splice(index, 1);
+            }
+        });
+        this.pendingExports.push(exportPromise);
+    }
+    forceFlush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`[SyncLogRecordProcessor] forceFlush called with ${this.pendingExports.length} pending exports`);
+            if (this.pendingExports.length === 0) {
+                console.log('[SyncLogRecordProcessor] No pending exports to flush');
+                return;
+            }
+            try {
+                yield Promise.all(this.pendingExports);
+                console.log('[SyncLogRecordProcessor] All pending exports completed');
+            }
+            catch (error) {
+                console.error('[SyncLogRecordProcessor] Error during forceFlush:', error);
+                throw error;
+            }
+        });
+    }
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('[SyncLogRecordProcessor] Shutting down...');
+            yield this.forceFlush();
+            yield this.exporter.shutdown();
+            console.log('[SyncLogRecordProcessor] Shutdown complete');
+        });
+    }
+}
+exports.TsedSyncLogRecordProcessor = TsedSyncLogRecordProcessor;
+//# sourceMappingURL=data:application/json;base64,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