@vtvlive/interactive-apm 0.0.2

package/dist/init/elastic-apm-init.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Elastic APM Initialization (Standalone)
+ *
+ * Use this to initialize Elastic APM agent before your application starts.
+ * This is useful for non-NestJS applications or when you need manual control.
+ *
+ * @example
+ * import { initElasticApm } from '@vtvlive/interactive-apm';
+ *
+ * // Initialize at the top of your application
+ * initElasticApm({
+ *   serviceName: 'my-service',
+ *   serverUrl: 'http://localhost:8200',
+ *   environment: 'production',
+ * });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseElasticApm = shouldUseElasticApm;
+exports.initElasticApm = initElasticApm;
+exports.isElasticApmStarted = isElasticApmStarted;
+exports.getElasticApmAgent = getElasticApmAgent;
+const apm_provider_type_1 = require("../types/apm-provider.type");
+/**
+ * Check if APM should use Elastic APM provider based on configuration
+ * @returns true if Elastic APM should be used
+ */
+function shouldUseElasticApm() {
+    const provider = process.env.APM_PROVIDER || apm_provider_type_1.ApmProvider.OPENTELEMETRY;
+    return provider === apm_provider_type_1.ApmProvider.ELASTIC_APM || provider === 'elastic-apm';
+}
+/**
+ * Initialize Elastic APM agent for standalone usage
+ *
+ * @param options Configuration options
+ * @returns The APM agent instance
+ */
+function initElasticApm(options = {}) {
+    // @ts-ignore - Optional peer dependency
+    const apm = require('elastic-apm-node');
+    // If already started, return the instance
+    if (apm.isStarted()) {
+        return apm;
+    }
+    // Start the agent
+    const agent = apm.start({
+        serviceName: options.serviceName || process.env.ELASTIC_APM_SERVICE_NAME || 'interactive-backend',
+        serverUrl: options.serverUrl || process.env.ELASTIC_APM_SERVER_URL || 'http://localhost:8200',
+        secretToken: options.secretToken || process.env.ELASTIC_APM_SECRET_TOKEN,
+        serviceVersion: options.serviceVersion || process.env.npm_package_version || '1.0.0',
+        environment: options.environment || process.env.ELASTIC_APM_ENVIRONMENT || 'development',
+        logLevel: options.logLevel || 'error',
+    });
+    console.log(`[ElasticAPM] Service: ${agent.getServiceName()}, Environment: ${agent.conf.environment}`);
+    console.log('[ElasticAPM] Initialized');
+    return agent;
+}
+/**
+ * Check if Elastic APM agent is started
+ */
+function isElasticApmStarted() {
+    try {
+        // @ts-ignore - Optional peer dependency
+        const apm = require('elastic-apm-node');
+        return apm.isStarted();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the Elastic APM agent instance
+ */
+function getElasticApmAgent() {
+    try {
+        // @ts-ignore - Optional peer dependency
+        const apm = require('elastic-apm-node');
+        if (apm.isStarted()) {
+            return apm;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/init/opentelemetry-init.d.ts

@@ -0,0 +1,51 @@
+/**
+ * OpenTelemetry Initialization (Standalone)
+ *
+ * Use this to initialize OpenTelemetry SDK for standalone usage.
+ * This is useful for non-NestJS applications or when you need manual control.
+ *
+ * @example
+ * import { initOpenTelemetry } from '@vtvlive/interactive-apm';
+ *
+ * // Initialize at the top of your application
+ * const sdk = initOpenTelemetry({
+ *   serviceName: 'my-service',
+ *   otlpEndpoint: 'http://localhost:8200/v1/traces',
+ *   environment: 'production',
+ * });
+ */
+export interface OpenTelemetryInitOptions {
+    /** Service name for APM */
+    serviceName?: string;
+    /** OTLP endpoint URL */
+    otlpEndpoint?: string;
+    /** Secret token for authentication */
+    secretToken?: string;
+    /** OTLP auth token (takes precedence over secretToken for OTLP) */
+    otlpAuthToken?: string;
+    /** OTLP headers as a record (key-value pairs). If provided, merges with Authorization header when token is set. */
+    otlpHeaders?: Record<string, string>;
+    /** Service version */
+    serviceVersion?: string;
+    /** Deployment environment */
+    environment?: string;
+    /** Enable console exporter for debugging */
+    enableConsoleExporter?: boolean;
+    /** Enable HTTP instrumentation */
+    enableHttpInstrumentation?: boolean;
+    /** Enable Express instrumentation */
+    enableExpressInstrumentation?: boolean;
+}
+/**
+ * Check if APM should use OpenTelemetry provider based on configuration
+ * @returns true if OpenTelemetry should be used
+ */
+export declare function shouldUseOpenTelemetry(): boolean;
+/**
+ * Initialize OpenTelemetry SDK for standalone usage
+ *
+ * @param options Configuration options
+ * @returns The NodeSDK instance
+ */
+export declare function initOpenTelemetry(options?: OpenTelemetryInitOptions): Promise<any>;
+//# sourceMappingURL=opentelemetry-init.d.ts.map

package/dist/init/opentelemetry-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentelemetry-init.d.ts","sourceRoot":"","sources":["../../src/init/opentelemetry-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,WAAW,wBAAwB;IACvC,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wBAAwB;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mHAAmH;IACnH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,sBAAsB;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,6BAA6B;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,kCAAkC;IAClC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,qCAAqC;IACrC,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACxC;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAGhD;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,GAAG,OAAO,CAAC,GAAG,CAAC,CAyG5F"}

package/dist/init/opentelemetry-init.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * OpenTelemetry Initialization (Standalone)
+ *
+ * Use this to initialize OpenTelemetry SDK for standalone usage.
+ * This is useful for non-NestJS applications or when you need manual control.
+ *
+ * @example
+ * import { initOpenTelemetry } from '@vtvlive/interactive-apm';
+ *
+ * // Initialize at the top of your application
+ * const sdk = initOpenTelemetry({
+ *   serviceName: 'my-service',
+ *   otlpEndpoint: 'http://localhost:8200/v1/traces',
+ *   environment: 'production',
+ * });
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseOpenTelemetry = shouldUseOpenTelemetry;
+exports.initOpenTelemetry = initOpenTelemetry;
+const apm_provider_type_1 = require("../types/apm-provider.type");
+/**
+ * Check if APM should use OpenTelemetry provider based on configuration
+ * @returns true if OpenTelemetry should be used
+ */
+function shouldUseOpenTelemetry() {
+    const provider = process.env.APM_PROVIDER || apm_provider_type_1.ApmProvider.OPENTELEMETRY;
+    return provider !== apm_provider_type_1.ApmProvider.ELASTIC_APM && provider !== 'elastic-apm';
+}
+/**
+ * Initialize OpenTelemetry SDK for standalone usage
+ *
+ * @param options Configuration options
+ * @returns The NodeSDK instance
+ */
+async function initOpenTelemetry(options = {}) {
+    // @ts-ignore - Optional peer dependency
+    const { NodeSDK } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/sdk-node')));
+    // @ts-ignore - Optional peer dependency
+    const { resourceFromAttributes } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/resources')));
+    // @ts-ignore - Optional peer dependency
+    const { OTLPTraceExporter } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/exporter-trace-otlp-http')));
+    console.log('[OpenTelemetry] Initializing...');
+    const serviceName = options.serviceName || process.env.ELASTIC_APM_SERVICE_NAME || 'interactive-backend';
+    const environment = options.environment || process.env.ELASTIC_APM_ENVIRONMENT || 'development';
+    const otlpEndpoint = options.otlpEndpoint || process.env.ELASTIC_OTLP_ENDPOINT || 'http://localhost:8200/v1/traces';
+    const secretToken = options.secretToken || process.env.ELASTIC_APM_SECRET_TOKEN;
+    const otlpAuthToken = options.otlpAuthToken || process.env.ELASTIC_OTLP_AUTH_TOKEN;
+    // Build headers: merge options.otlpHeaders with Authorization if token is provided
+    const headers = { ...options.otlpHeaders };
+    const token = otlpAuthToken || secretToken;
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+    console.log(`[OpenTelemetry] Service: ${serviceName}, Environment: ${environment}`);
+    console.log(`[OpenTelemetry] Endpoint: ${otlpEndpoint}`);
+    // Build exporters array
+    const exporters = [];
+    // OTLP Exporter with detailed logging
+    const otlpExporterBase = new OTLPTraceExporter({
+        url: otlpEndpoint,
+        headers: Object.keys(headers).length > 0 ? headers : undefined,
+    });
+    // Wrap OTLP exporter - only log errors
+    const otlpExporter = {
+        export: (spans, resultCallback) => {
+            otlpExporterBase.export(spans, (result) => {
+                if (result.error) {
+                    console.error(`[OpenTelemetry] Export failed: ${result.error instanceof Error ? result.error.message : result.error}`);
+                }
+                resultCallback(result);
+            });
+        },
+        shutdown: async () => {
+            await otlpExporterBase.shutdown();
+        },
+    };
+    exporters.push(otlpExporter);
+    // Console Exporter for debugging
+    if (options.enableConsoleExporter ?? process.env.ELASTIC_OTLP_ENABLE_CONSOLE_EXPORTER === 'true') {
+        // @ts-ignore - Optional peer dependency
+        const { ConsoleSpanExporter } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/sdk-trace-base')));
+        exporters.push(new ConsoleSpanExporter());
+    }
+    // Build instrumentations array
+    const instrumentations = [];
+    if (options.enableHttpInstrumentation !== false) {
+        // @ts-ignore - Optional peer dependency
+        const { HttpInstrumentation } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/instrumentation-http')));
+        instrumentations.push(new HttpInstrumentation());
+    }
+    if (options.enableExpressInstrumentation !== false) {
+        // @ts-ignore - Optional peer dependency
+        const { ExpressInstrumentation } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/instrumentation-express')));
+        instrumentations.push(new ExpressInstrumentation());
+    }
+    // Resource attributes
+    const sdkResource = resourceFromAttributes({
+        'service.name': serviceName,
+        'deployment.environment': environment,
+        'service.version': options.serviceVersion || process.env.npm_package_version || '1.0.0',
+        'service.instance.id': `${process.pid}`,
+        'host.name': require('os').hostname(),
+    });
+    // Initialize SDK
+    const sdk = new NodeSDK({
+        serviceName,
+        traceExporter: exporters.length === 1 ? exporters[0] : exporters, // Handle single/multiple exporters
+        instrumentations,
+        resource: sdkResource,
+    });
+    // Start SDK
+    sdk.start();
+    console.log('[OpenTelemetry] Initialized');
+    // Setup graceful shutdown handlers
+    const shutdown = async () => {
+        await sdk.shutdown();
+        process.exit(0);
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+    return sdk;
+}

package/dist/interfaces/tracing-provider.interface.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Interface chung cho APM Tracing Provider
+ * Cho phép switch giữa OpenTelemetry và Elastic APM thông qua DI
+ */
+export interface ITracingProvider {
+    /**
+     * Bắt đầu một span mới để trace operation
+     * @param name Tên của span
+     * @param attributes Các attributes metadata
+     * @param spanKind Loại span (INTERNAL, SERVER, CLIENT, PRODUCER, CONSUMER)
+     * @returns Span object - cần gọi end() khi hoàn thành
+     */
+    startSpan(name: string, attributes?: Record<string, string | number>, spanKind?: string): any;
+    /**
+     * Thực thi function với context tracing (auto-close span)
+     * @param name Tên của span
+     * @param fn Function cần trace
+     * @param attributes Các attributes metadata
+     * @returns Kết quả của function
+     */
+    startSpanWithParent<T>(name: string, fn: (span: any) => Promise<T>, attributes?: Record<string, string | number>): Promise<T>;
+    /**
+     * Capture error vào active span hiện tại
+     * @param error Error object
+     */
+    captureError(error: Error): void;
+    /**
+     * Set attribute cho active span hiện tại
+     * @param key Tên attribute
+     * @param value Giá trị attribute
+     */
+    setAttribute(key: string, value: string | number): void;
+    /**
+     * Kết thúc span manually
+     * @param span Span cần end (nếu không truyền, sẽ end active span)
+     */
+    endSpan(span?: any): void;
+    /**
+     * Flush và shutdown provider (cho graceful shutdown)
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=tracing-provider.interface.d.ts.map

package/dist/interfaces/tracing-provider.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing-provider.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/tracing-provider.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IAE9F;;;;;;OAMG;IACH,mBAAmB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAE9H;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAEjC;;;;OAIG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAExD;;;OAGG;IACH,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B"}

package/dist/interfaces/tracing-provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/tracing.module.d.ts

@@ -0,0 +1,96 @@
+import { DynamicModule } from '@nestjs/common';
+import { ApmProvider } from '../types/apm-provider.type';
+/**
+ * Options for configuring TracingModule
+ */
+export interface TracingModuleOptions {
+    /** Provider type: 'elastic-apm' or 'opentelemetry' (default: from env or 'opentelemetry') */
+    provider?: ApmProvider | string;
+    /** Service name for APM */
+    serviceName?: string;
+    /** Deployment environment */
+    environment?: string;
+    /** Elastic APM server URL (for elastic-apm provider) */
+    serverUrl?: string;
+    /** Secret token for authentication */
+    secretToken?: string;
+    /** OTLP endpoint URL (for opentelemetry provider) */
+    otlpEndpoint?: string;
+    /** Service version */
+    serviceVersion?: string;
+    /** Auto-initialize the provider on module init */
+    autoInit?: boolean;
+}
+/**
+ * TracingModule - Module cung cấp APM Tracing functionality cho NestJS
+ *
+ * Sử dụng decorator @Global để TracingService có thể được inject ở mọi nơi
+ * mà không cần import module vào từng module con.
+ *
+ * @example
+ * // Trong app.module.ts - Basic usage (reads from environment)
+ * import { TracingModule } from '@vtvlive/interactive-apm';
+ *
+ * @Module({
+ *   imports: [
+ *     TracingModule.registerAsync(),
+ *     // ... other modules
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * @example
+ * // Trong app.module.ts - With explicit options
+ * @Module({
+ *   imports: [
+ *     TracingModule.register({
+ *       provider: 'opentelemetry',
+ *       serviceName: 'my-service',
+ *       otlpEndpoint: 'http://localhost:8200/v1/traces',
+ *     }),
+ *     // ... other modules
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * @example
+ * // Trong controller/service
+ * constructor(private readonly tracingService: TracingService) {}
+ *
+ * async someMethod() {
+ *   const span = this.tracingService.startSpan('operation', {}, 'SERVER');
+ *   try {
+ *     // ... code
+ *   } finally {
+ *     span.end();
+ *   }
+ * }
+ */
+export declare class TracingModule {
+    /**
+     * Register module with synchronous options
+     */
+    static register(options?: TracingModuleOptions): DynamicModule;
+    /**
+     * Register module with asynchronous options (using ConfigService)
+     */
+    static registerAsync(options?: TracingModuleAsyncOptions): DynamicModule;
+}
+/**
+ * Async options for TracingModule
+ */
+export interface TracingModuleAsyncOptions {
+    /**
+     * Optional list of modules to import for the factory to use
+     */
+    imports?: any[];
+    /**
+     * Factory function that returns the module options
+     */
+    useFactory?: (...args: any[]) => Promise<TracingModuleOptions> | TracingModuleOptions;
+    /**
+     * Optional list of providers to inject into the factory
+     */
+    inject?: any[];
+}
+//# sourceMappingURL=tracing.module.d.ts.map

package/dist/modules/tracing.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing.module.d.ts","sourceRoot":"","sources":["../../src/modules/tracing.module.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG/D,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;IAChC,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6BAA6B;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sBAAsB;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBAEa,aAAa;IACxB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,OAAO,GAAE,oBAAyB,GAAG,aAAa;IAoBlE;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,OAAO,GAAE,yBAA8B,GAAG,aAAa;CAgC7E;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;OAEG;IACH,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAEhB;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,oBAAoB,CAAC,GAAG,oBAAoB,CAAC;IAEtF;;OAEG;IACH,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC;CAChB"}

package/dist/modules/tracing.module.js

@@ -0,0 +1,162 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TracingModule = void 0;
+// @ts-ignore - Optional peer dependency
+const common_1 = require("@nestjs/common");
+const tracing_service_1 = require("../services/tracing.service");
+const tracing_provider_factory_1 = require("../factories/tracing-provider.factory");
+/**
+ * TracingModule - Module cung cấp APM Tracing functionality cho NestJS
+ *
+ * Sử dụng decorator @Global để TracingService có thể được inject ở mọi nơi
+ * mà không cần import module vào từng module con.
+ *
+ * @example
+ * // Trong app.module.ts - Basic usage (reads from environment)
+ * import { TracingModule } from '@vtvlive/interactive-apm';
+ *
+ * @Module({
+ *   imports: [
+ *     TracingModule.registerAsync(),
+ *     // ... other modules
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * @example
+ * // Trong app.module.ts - With explicit options
+ * @Module({
+ *   imports: [
+ *     TracingModule.register({
+ *       provider: 'opentelemetry',
+ *       serviceName: 'my-service',
+ *       otlpEndpoint: 'http://localhost:8200/v1/traces',
+ *     }),
+ *     // ... other modules
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * @example
+ * // Trong controller/service
+ * constructor(private readonly tracingService: TracingService) {}
+ *
+ * async someMethod() {
+ *   const span = this.tracingService.startSpan('operation', {}, 'SERVER');
+ *   try {
+ *     // ... code
+ *   } finally {
+ *     span.end();
+ *   }
+ * }
+ */
+let TracingModule = (() => {
+    let _classDecorators = [(0, common_1.Global)(), (0, common_1.Module)({})];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var TracingModule = _classThis = class {
+        /**
+         * Register module with synchronous options
+         */
+        static register(options = {}) {
+            const tracingProvider = (0, tracing_provider_factory_1.createTracingProvider)(options);
+            return {
+                module: TracingModule,
+                providers: [
+                    {
+                        provide: tracing_provider_factory_1.TRACING_PROVIDER_TOKEN,
+                        useValue: tracingProvider,
+                    },
+                    {
+                        provide: tracing_service_1.TracingService,
+                        useFactory: (provider) => new tracing_service_1.TracingService(provider),
+                        inject: [tracing_provider_factory_1.TRACING_PROVIDER_TOKEN],
+                    },
+                ],
+                exports: [tracing_service_1.TracingService],
+            };
+        }
+        /**
+         * Register module with asynchronous options (using ConfigService)
+         */
+        static registerAsync(options = {}) {
+            return {
+                module: TracingModule,
+                imports: options.imports || [],
+                providers: [
+                    {
+                        provide: tracing_provider_factory_1.TRACING_PROVIDER_TOKEN,
+                        useFactory: async (...args) => {
+                            const config = options.useFactory ? await options.useFactory(...args) : {};
+                            const provider = (0, tracing_provider_factory_1.createTracingProvider)(config);
+                            // Auto-initialize if configured
+                            if (config.autoInit !== false) {
+                                // Check if provider has initialize method (not in interface)
+                                if (provider.initialize && typeof provider.initialize === 'function') {
+                                    await provider.initialize();
+                                }
+                            }
+                            return provider;
+                        },
+                        inject: options.inject || [],
+                    },
+                    {
+                        provide: tracing_service_1.TracingService,
+                        useFactory: (provider) => new tracing_service_1.TracingService(provider),
+                        inject: [tracing_provider_factory_1.TRACING_PROVIDER_TOKEN],
+                    },
+                ],
+                exports: [tracing_service_1.TracingService],
+            };
+        }
+    };
+    __setFunctionName(_classThis, "TracingModule");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        TracingModule = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return TracingModule = _classThis;
+})();
+exports.TracingModule = TracingModule;

package/dist/providers/elastic-apm.tracing-provider.d.ts

@@ -0,0 +1,57 @@
+import { ITracingProvider } from '../interfaces/tracing-provider.interface';
+/**
+ * Elastic APM Tracing Provider Implementation
+ * Sử dụng elastic-apm-node agent để gửi traces về Elastic APM server
+ */
+export declare class ElasticApmTracingProvider implements ITracingProvider {
+    private apm;
+    private readonly serviceName;
+    private readonly environment;
+    constructor(config?: {
+        serviceName?: string;
+        environment?: string;
+        serverUrl?: string;
+        secretToken?: string;
+        serviceVersion?: string;
+    });
+    /**
+     * Initialize Elastic APM agent
+     * Should be called before using the provider
+     */
+    initialize(config?: {
+        serviceName?: string;
+        serverUrl?: string;
+        secretToken?: string;
+        environment?: string;
+        serviceVersion?: string;
+    }): void;
+    /**
+     * Bắt đầu một span mới
+     */
+    startSpan(name: string, attributes?: Record<string, string | number>, spanKind?: string): any;
+    /**
+     * Thực thi function với tracing context
+     */
+    startSpanWithParent<T>(name: string, fn: (span: any) => Promise<T>, attributes?: Record<string, string | number>): Promise<T>;
+    /**
+     * Capture error vào APM
+     */
+    captureError(error: Error): void;
+    /**
+     * Set label cho current transaction/span
+     */
+    setAttribute(key: string, value: string | number): void;
+    /**
+     * End span manually
+     */
+    endSpan(span?: any): void;
+    /**
+     * Flush và shutdown gracefully
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Map string span kind to Elastic APM span type
+     */
+    private mapSpanKindToType;
+}
+//# sourceMappingURL=elastic-apm.tracing-provider.d.ts.map

package/dist/providers/elastic-apm.tracing-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elastic-apm.tracing-provider.d.ts","sourceRoot":"","sources":["../../src/providers/elastic-apm.tracing-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAE5E;;;GAGG;AACH,qBAAa,yBAA0B,YAAW,gBAAgB;IAChE,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAEzB,MAAM,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAO;IAK1I;;;OAGG;IACH,UAAU,CAAC,MAAM,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IA6B5I;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAAE,QAAQ,GAAE,MAAmB,GAAG,GAAG;IAkDzG;;OAEG;IACG,mBAAmB,CAAC,CAAC,EACzB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,EAC7B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAC3C,OAAO,CAAC,CAAC,CAAC;IAmBb;;OAEG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAMhC;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOvD;;OAEG;IACH,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAOzB;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAM/B;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAe1B"}