@vtvlive/interactive-apm 0.0.2

package/dist/providers/elastic-apm.tracing-provider.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElasticApmTracingProvider = void 0;
+/**
+ * Elastic APM Tracing Provider Implementation
+ * Sử dụng elastic-apm-node agent để gửi traces về Elastic APM server
+ */
+class ElasticApmTracingProvider {
+    constructor(config = {}) {
+        this.apm = null;
+        this.serviceName = config.serviceName || process.env.ELASTIC_APM_SERVICE_NAME || 'interactive-backend';
+        this.environment = config.environment || process.env.ELASTIC_APM_ENVIRONMENT || 'development';
+    }
+    /**
+     * Initialize Elastic APM agent
+     * Should be called before using the provider
+     */
+    initialize(config) {
+        try {
+            // @ts-ignore - Optional peer dependency
+            const apm = require('elastic-apm-node');
+            // If agent is already started, just get reference
+            if (apm.isStarted()) {
+                this.apm = apm;
+                return;
+            }
+            // Start the agent with provided config
+            this.apm = apm.start({
+                serviceName: config?.serviceName || this.serviceName,
+                serverUrl: config?.serverUrl || process.env.ELASTIC_APM_SERVER_URL || 'http://localhost:8200',
+                secretToken: config?.secretToken || process.env.ELASTIC_APM_SECRET_TOKEN,
+                serviceVersion: config?.serviceVersion || process.env.npm_package_version || '1.0.0',
+                environment: config?.environment || this.environment,
+                logLevel: 'error',
+            });
+            console.log(`[ElasticAPM] Service: ${this.serviceName}, Environment: ${this.environment}`);
+            console.log('[ElasticAPM] Initialized');
+        }
+        catch (error) {
+            console.error('[ElasticAPM] Failed to initialize:', error);
+            throw error;
+        }
+    }
+    /**
+     * Bắt đầu một span mới
+     */
+    startSpan(name, attributes, spanKind = 'INTERNAL') {
+        if (!this.apm) {
+            console.warn('[ElasticAPM] Not initialized');
+            return null;
+        }
+        // Elastic APM cần transaction để tạo span
+        let transaction = this.apm.currentTransaction;
+        let createdTransaction = false;
+        if (!transaction) {
+            const type = this.mapSpanKindToType(spanKind);
+            transaction = this.apm.startTransaction(name, type);
+            if (!transaction) {
+                return null;
+            }
+            createdTransaction = true;
+        }
+        const span = this.apm.startSpan(name, 'custom');
+        if (!span) {
+            if (createdTransaction && transaction) {
+                transaction.end();
+            }
+            return null;
+        }
+        // Set labels từ attributes
+        if (attributes) {
+            for (const [key, value] of Object.entries(attributes)) {
+                span.setLabel(key, String(value));
+            }
+        }
+        // Set span type dựa trên kind
+        span.setType(this.mapSpanKindToType(spanKind));
+        // Override end() để end transaction sau
+        const originalEnd = span.end.bind(span);
+        span.end = () => {
+            originalEnd();
+            if (createdTransaction && transaction) {
+                transaction.end();
+            }
+        };
+        return span;
+    }
+    /**
+     * Thực thi function với tracing context
+     */
+    async startSpanWithParent(name, fn, attributes) {
+        const span = this.startSpan(name, attributes);
+        try {
+            const result = await fn(span);
+            return result;
+        }
+        catch (error) {
+            this.apm?.captureError(error);
+            if (span) {
+                span.outcome = 'failure';
+            }
+            throw error;
+        }
+        finally {
+            if (span) {
+                span.end();
+            }
+        }
+    }
+    /**
+     * Capture error vào APM
+     */
+    captureError(error) {
+        if (this.apm) {
+            this.apm.captureError(error);
+        }
+    }
+    /**
+     * Set label cho current transaction/span
+     */
+    setAttribute(key, value) {
+        const span = this.apm?.currentSpan;
+        if (span) {
+            span.setLabel(key, String(value));
+        }
+    }
+    /**
+     * End span manually
+     */
+    endSpan(span) {
+        const activeSpan = span || this.apm?.currentSpan;
+        if (activeSpan) {
+            activeSpan.end();
+        }
+    }
+    /**
+     * Flush và shutdown gracefully
+     */
+    async shutdown() {
+        if (this.apm) {
+            await this.apm.flush();
+        }
+    }
+    /**
+     * Map string span kind to Elastic APM span type
+     */
+    mapSpanKindToType(kind) {
+        switch (kind.toUpperCase()) {
+            case 'SERVER':
+                return 'request';
+            case 'CLIENT':
+                return 'db';
+            case 'PRODUCER':
+                return 'messaging';
+            case 'CONSUMER':
+                return 'messaging';
+            case 'INTERNAL':
+            default:
+                return 'code';
+        }
+    }
+}
+exports.ElasticApmTracingProvider = ElasticApmTracingProvider;

package/dist/providers/opentelemetry.tracing-provider.d.ts

@@ -0,0 +1,68 @@
+import { ITracingProvider } from '../interfaces/tracing-provider.interface';
+/**
+ * OpenTelemetry Tracing Provider Implementation
+ * Sử dụng OpenTelemetry SDK với OTLP exporter để gửi traces về Elastic APM
+ */
+export declare class OpenTelemetryTracingProvider implements ITracingProvider {
+    private sdk;
+    private tracer;
+    private readonly serviceName;
+    private readonly environment;
+    private readonly otlpEndpoint;
+    private readonly secretToken;
+    private readonly otlpAuthToken;
+    private readonly otlpHeaders;
+    private readonly enableConsoleExporter;
+    private initialized;
+    constructor(config?: {
+        serviceName?: string;
+        environment?: string;
+        otlpEndpoint?: string;
+        secretToken?: string;
+        otlpAuthToken?: string;
+        otlpHeaders?: Record<string, string>;
+        enableConsoleExporter?: boolean;
+    });
+    /**
+     * Initialize OpenTelemetry SDK
+     * Should be called before using the provider
+     */
+    initialize(config?: {
+        serviceName?: string;
+        otlpEndpoint?: string;
+        secretToken?: string;
+        otlpAuthToken?: string;
+        otlpHeaders?: Record<string, string>;
+        enableConsoleExporter?: boolean;
+        environment?: string;
+    }): Promise<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 active span
+     */
+    captureError(error: Error): void;
+    /**
+     * Set attribute cho active span
+     */
+    setAttribute(key: string, value: string | number): void;
+    /**
+     * End span manually
+     */
+    endSpan(span?: any): void;
+    /**
+     * Shutdown gracefully
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Map string span kind to OpenTelemetry SpanKind enum
+     */
+    private mapSpanKind;
+}
+//# sourceMappingURL=opentelemetry.tracing-provider.d.ts.map

package/dist/providers/opentelemetry.tracing-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentelemetry.tracing-provider.d.ts","sourceRoot":"","sources":["../../src/providers/opentelemetry.tracing-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAE5E;;;GAGG;AACH,qBAAa,4BAA6B,YAAW,gBAAgB;IACnE,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;IACrD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAU;IAChD,OAAO,CAAC,WAAW,CAAS;gBAEhB,MAAM,GAAE;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACrC,qBAAqB,CAAC,EAAE,OAAO,CAAC;KAC5B;IAUN;;;OAGG;IACG,UAAU,CAAC,MAAM,CAAC,EAAE;QACxB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACrC,qBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC,IAAI,CAAC;IAwIjB;;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;IAqBzG;;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;IAoBb;;OAEG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAchC;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAavD;;OAEG;IACH,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAazB;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAM/B;;OAEG;IACH,OAAO,CAAC,WAAW;CAiBpB"}

package/dist/providers/opentelemetry.tracing-provider.js

@@ -0,0 +1,288 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenTelemetryTracingProvider = void 0;
+/**
+ * OpenTelemetry Tracing Provider Implementation
+ * Sử dụng OpenTelemetry SDK với OTLP exporter để gửi traces về Elastic APM
+ */
+class OpenTelemetryTracingProvider {
+    constructor(config = {}) {
+        this.sdk = null;
+        this.tracer = null;
+        this.initialized = false;
+        this.serviceName = config.serviceName || process.env.ELASTIC_APM_SERVICE_NAME || 'interactive-backend';
+        this.environment = config.environment || process.env.ELASTIC_APM_ENVIRONMENT || 'development';
+        this.otlpEndpoint = config.otlpEndpoint || process.env.ELASTIC_OTLP_ENDPOINT || 'http://localhost:8200/v1/traces';
+        this.secretToken = config.secretToken || process.env.ELASTIC_APM_SECRET_TOKEN || '';
+        this.otlpAuthToken = config.otlpAuthToken || process.env.ELASTIC_OTLP_AUTH_TOKEN || '';
+        this.otlpHeaders = config.otlpHeaders || {};
+        this.enableConsoleExporter = config.enableConsoleExporter ?? process.env.ELASTIC_OTLP_ENABLE_CONSOLE_EXPORTER === 'true';
+    }
+    /**
+     * Initialize OpenTelemetry SDK
+     * Should be called before using the provider
+     */
+    async initialize(config) {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            // Dynamic import to avoid errors when @opentelemetry packages are not installed
+            // @ts-ignore - Optional peer dependency
+            const { NodeSDK } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/sdk-node')));
+            // @ts-ignore - Optional peer dependency
+            const { HttpInstrumentation } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/instrumentation-http')));
+            // @ts-ignore - Optional peer dependency
+            const { ExpressInstrumentation } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/instrumentation-express')));
+            // @ts-ignore - Optional peer dependency
+            const { OTLPTraceExporter } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/exporter-trace-otlp-http')));
+            // @ts-ignore - Optional peer dependency
+            const { resourceFromAttributes } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/resources')));
+            // @ts-ignore - Optional peer dependency
+            const { trace } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/api')));
+            console.log(`[OpenTelemetry] Service: ${this.serviceName}, Environment: ${this.environment}`);
+            console.log(`[OpenTelemetry] Endpoint: ${config?.otlpEndpoint || this.otlpEndpoint}`);
+            // OTLP Exporter - Build headers with Authorization
+            const buildHeaders = () => {
+                const headers = {
+                    ...this.otlpHeaders,
+                    ...(config?.otlpHeaders || {}),
+                };
+                const token = config?.otlpAuthToken || this.otlpAuthToken || config?.secretToken || this.secretToken;
+                if (token) {
+                    headers['Authorization'] = `Bearer ${token}`;
+                }
+                return Object.keys(headers).length > 0 ? headers : undefined;
+            };
+            const otlpExporter = new OTLPTraceExporter({
+                url: config?.otlpEndpoint || this.otlpEndpoint,
+                headers: buildHeaders(),
+            });
+            // Wrap OTLP exporter - only log errors
+            const otlpExporterWithLogging = {
+                export: (spans, resultCallback) => {
+                    otlpExporter.export(spans, (result) => {
+                        if (result.error) {
+                            const endpoint = config?.otlpEndpoint || this.otlpEndpoint;
+                            console.error(`[OpenTelemetry] Export to ${endpoint} failed: ${result.error instanceof Error ? result.error.message : result.error}`);
+                        }
+                        resultCallback(result);
+                    });
+                },
+                shutdown: async () => {
+                    await otlpExporter.shutdown();
+                },
+            };
+            // Use console exporter if enabled
+            const shouldEnableConsole = config?.enableConsoleExporter ?? this.enableConsoleExporter;
+            let traceExporter = otlpExporterWithLogging;
+            if (shouldEnableConsole) {
+                // @ts-ignore - Optional peer dependency
+                const { ConsoleSpanExporter } = await Promise.resolve().then(() => __importStar(require('@opentelemetry/sdk-trace-base')));
+                const consoleExporter = new ConsoleSpanExporter();
+                // Combined Exporter để export ra cả console và OTLP
+                traceExporter = {
+                    export: (spans, resultCallback) => {
+                        let completed = 0;
+                        let hasError = false;
+                        const errors = [];
+                        const checkComplete = () => {
+                            if (completed === 2) {
+                                resultCallback(hasError ? { code: 1, error: new Error(errors.map(e => e.message).join('; ')) } : { code: 0 });
+                            }
+                        };
+                        // Console exporter
+                        consoleExporter.export(spans, (result) => {
+                            if (result.error) {
+                                hasError = true;
+                                errors.push(result.error);
+                            }
+                            completed++;
+                            checkComplete();
+                        });
+                        // OTLP exporter with logging
+                        otlpExporterWithLogging.export(spans, (result) => {
+                            if (result.error) {
+                                hasError = true;
+                                errors.push(result.error);
+                            }
+                            completed++;
+                            checkComplete();
+                        });
+                    },
+                    shutdown: async () => {
+                        await Promise.all([consoleExporter.shutdown(), otlpExporterWithLogging.shutdown()]);
+                    },
+                };
+            }
+            // Resource attributes
+            const sdkResource = resourceFromAttributes({
+                'service.name': config?.serviceName || this.serviceName,
+                'deployment.environment': config?.environment || this.environment,
+                'service.version': process.env.npm_package_version || '1.0.0',
+                'service.instance.id': `${process.pid}`,
+                'host.name': require('os').hostname(),
+            });
+            // Khởi tạo SDK
+            this.sdk = new NodeSDK({
+                serviceName: config?.serviceName || this.serviceName,
+                traceExporter,
+                instrumentations: [new HttpInstrumentation(), new ExpressInstrumentation()],
+                resource: sdkResource,
+            });
+            // Khởi động SDK
+            this.sdk.start();
+            // Get tracer
+            this.tracer = trace.getTracer(config?.serviceName || this.serviceName);
+            this.initialized = true;
+            console.log('[OpenTelemetry] Initialized');
+        }
+        catch (error) {
+            console.error('[OpenTelemetry] Failed to initialize:', error);
+            throw error;
+        }
+    }
+    /**
+     * Bắt đầu một span mới
+     */
+    startSpan(name, attributes, spanKind = 'INTERNAL') {
+        if (!this.initialized || !this.tracer) {
+            console.warn('[OpenTelemetry] Not initialized');
+            return null;
+        }
+        // @ts-ignore - Optional peer dependency
+        const { context, SpanKind } = require('@opentelemetry/api');
+        const span = this.tracer.startSpan(name, {
+            attributes,
+            kind: this.mapSpanKind(spanKind),
+        }, context.active());
+        return span;
+    }
+    /**
+     * Thực thi function với tracing context
+     */
+    async startSpanWithParent(name, fn, attributes) {
+        // @ts-ignore - Optional peer dependency
+        const { context, trace, SpanStatusCode } = require('@opentelemetry/api');
+        return context.with(trace.setSpan(context.active(), this.startSpan(name, attributes)), async () => {
+            const span = trace.getActiveSpan();
+            try {
+                const result = await fn(span);
+                return result;
+            }
+            catch (error) {
+                span?.recordException(error);
+                span?.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                throw error;
+            }
+            finally {
+                span?.end();
+            }
+        });
+    }
+    /**
+     * Capture error vào active span
+     */
+    captureError(error) {
+        if (!this.initialized) {
+            return;
+        }
+        // @ts-ignore - Optional peer dependency
+        const { trace, SpanStatusCode } = require('@opentelemetry/api');
+        const span = trace.getActiveSpan();
+        if (span) {
+            span.recordException(error);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        }
+    }
+    /**
+     * Set attribute cho active span
+     */
+    setAttribute(key, value) {
+        if (!this.initialized) {
+            return;
+        }
+        // @ts-ignore - Optional peer dependency
+        const { trace } = require('@opentelemetry/api');
+        const span = trace.getActiveSpan();
+        if (span) {
+            span.setAttribute(key, value);
+        }
+    }
+    /**
+     * End span manually
+     */
+    endSpan(span) {
+        if (!this.initialized) {
+            return;
+        }
+        // @ts-ignore - Optional peer dependency
+        const { trace } = require('@opentelemetry/api');
+        const activeSpan = span || trace.getActiveSpan();
+        if (activeSpan) {
+            activeSpan.end();
+        }
+    }
+    /**
+     * Shutdown gracefully
+     */
+    async shutdown() {
+        if (this.sdk) {
+            await this.sdk.shutdown();
+        }
+    }
+    /**
+     * Map string span kind to OpenTelemetry SpanKind enum
+     */
+    mapSpanKind(kind) {
+        // @ts-ignore - Optional peer dependency
+        const { SpanKind } = require('@opentelemetry/api');
+        switch (kind.toUpperCase()) {
+            case 'SERVER':
+                return SpanKind.SERVER;
+            case 'CLIENT':
+                return SpanKind.CLIENT;
+            case 'PRODUCER':
+                return SpanKind.PRODUCER;
+            case 'CONSUMER':
+                return SpanKind.CONSUMER;
+            case 'INTERNAL':
+            default:
+                return SpanKind.INTERNAL;
+        }
+    }
+}
+exports.OpenTelemetryTracingProvider = OpenTelemetryTracingProvider;

package/dist/services/tracing.service.d.ts

@@ -0,0 +1,88 @@
+import { ITracingProvider } from '../interfaces/tracing-provider.interface';
+/**
+ * Tracing Service - Wrapper cho ITracingProvider
+ * Service này được inject vào controllers/services để sử dụng tracing
+ *
+ * Provider implementation (OpenTelemetry hoặc Elastic APM) được inject thông qua DI
+ *
+ * @example
+ * // NestJS usage
+ * constructor(private readonly tracingService: TracingService) {}
+ *
+ * someMethod() {
+ *   const span = this.tracingService.startSpan('my.operation', { 'key': 'value' }, 'SERVER');
+ *   try {
+ *     // ... code
+ *   } finally {
+ *     span.end();
+ *   }
+ * }
+ *
+ * @example
+ * // Standalone usage
+ * const provider = createTracingProvider();
+ * const tracingService = new TracingService(provider);
+ */
+export declare class TracingService {
+    private readonly provider;
+    constructor(provider: 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 (mặc định: INTERNAL)
+     *   - INTERNAL: Internal operation
+     *   - SERVER: Server-side request handler (API endpoints)
+     *   - CLIENT: Client-side call (outgoing HTTP, database)
+     *   - PRODUCER: Message producer
+     *   - CONSUMER: Message consumer
+     * @returns Span object - cần gọi end() khi hoàn thành
+     *
+     * @example
+     * const span = this.tracingService.startSpan('my.operation', { 'key': 'value' }, 'SERVER');
+     * try {
+     *   // ... code
+     * } finally {
+     *   span.end();
+     * }
+     */
+    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
+     *
+     * @example
+     * const result = await this.tracingService.startSpanWithParent(
+     *   'my.operation',
+     *   async (span) => {
+     *     span.setAttribute('custom', 'value');
+     *     return await someAsyncOperation();
+     *   }
+     * );
+     */
+    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 APM provider (cho graceful shutdown)
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=tracing.service.d.ts.map

package/dist/services/tracing.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing.service.d.ts","sourceRoot":"","sources":["../../src/services/tracing.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,gBAAgB;IAEvD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAAE,QAAQ,GAAE,MAAmB,GAAG,GAAG;IAIzG;;;;;;;;;;;;;;;OAeG;IACH,mBAAmB,CAAC,CAAC,EACnB,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;IAIb;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAIhC;;;;OAIG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIvD;;;OAGG;IACH,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAIzB;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}