@vtvlive/interactive-apm 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 VTVLive
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,320 @@
+# @vtvlive/interactive-apm
+
+> APM integration package supporting both Elastic APM and OpenTelemetry with NestJS integration
+
+## Features
+
+- **Dual APM Provider Support**: Switch between Elastic APM and OpenTelemetry via environment variable
+- **NestJS Integration**: Ready-to-use module with dependency injection
+- **Standalone Usage**: Works without NestJS for vanilla TypeScript/JavaScript projects
+- **Flexible Configuration**: Configure via environment variables or programmatic options
+- **TypeScript Support**: Fully typed with TypeScript
+
+## Installation
+
+### For OpenTelemetry
+
+```bash
+npm install @vtvlive/interactive-apm @opentelemetry/api @opentelemetry/exporter-trace-otlp-http @opentelemetry/instrumentation-http @opentelemetry/sdk-node @opentelemetry/resources
+```
+
+### For Elastic APM
+
+```bash
+npm install @vtvlive/interactive-apm elastic-apm-node
+```
+
+### For NestJS Integration
+
+Add the required NestJS dependencies:
+
+```bash
+npm install @nestjs/common @nestjs/config
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `APM_PROVIDER` | Provider selection: `elastic-apm` or `opentelemetry` | `opentelemetry` |
+| `ELASTIC_APM_SERVICE_NAME` | Service name for APM | Required |
+| `ELASTIC_APM_SERVER_URL` | Elastic APM server URL | `http://localhost:8200` |
+| `ELASTIC_APM_SECRET_TOKEN` | Secret token for authentication | Optional |
+| `ELASTIC_APM_ENVIRONMENT` | Deployment environment | `development` |
+| `ELASTIC_OTLP_ENDPOINT` | OTLP endpoint (OpenTelemetry only) | `http://localhost:8200/v1/traces` |
+| `ELASTIC_OTLP_AUTH_TOKEN` | OTLP-specific auth token (takes precedence over `ELASTIC_APM_SECRET_TOKEN`) | Optional |
+| `ELASTIC_OTLP_ENABLE_CONSOLE_EXPORTER` | Enable console exporter for debugging (default: `false`) | `false` |
+
+## Usage
+
+### NestJS Integration
+
+#### Basic Usage (reads from environment)
+
+```typescript
+// app.module.ts
+import { TracingModule } from '@vtvlive/interactive-apm';
+
+@Module({
+  imports: [
+    TracingModule.registerAsync(),
+    // ... other modules
+  ],
+})
+export class AppModule {}
+```
+
+#### With Explicit Options
+
+```typescript
+// app.module.ts
+import { TracingModule } from '@vtvlive/interactive-apm';
+
+@Module({
+  imports: [
+    TracingModule.register({
+      provider: 'opentelemetry',
+      serviceName: 'my-service',
+      otlpEndpoint: 'http://localhost:8200/v1/traces',
+      environment: 'production',
+      autoInit: true,
+    }),
+    // ... other modules
+  ],
+})
+export class AppModule {}
+```
+
+#### Using ConfigService
+
+```typescript
+// app.module.ts
+import { TracingModule } from '@vtvlive/interactive-apm';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+
+@Module({
+  imports: [
+    TracingModule.registerAsync({
+      imports: [ConfigModule],
+      useFactory: (configService: ConfigService) => ({
+        provider: configService.get('APM_PROVIDER'),
+        serviceName: configService.get('ELASTIC_APM_SERVICE_NAME'),
+        environment: configService.get('ELASTIC_APM_ENVIRONMENT'),
+      }),
+      inject: [ConfigService],
+    }),
+    // ... other modules
+  ],
+})
+export class AppModule {}
+```
+
+#### In Controllers/Services
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { TracingService } from '@vtvlive/interactive-apm';
+
+@Injectable()
+export class UserService {
+  constructor(private readonly tracingService: TracingService) {}
+
+  async findById(id: string) {
+    const span = this.tracingService.startSpan('user.findById', { userId: id }, 'SERVER');
+
+    try {
+      const user = await this.userRepository.findById(id);
+      return user;
+    } catch (error) {
+      this.tracingService.captureError(error);
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+
+  async create(data: CreateUserDto) {
+    return this.tracingService.startSpanWithParent(
+      'user.create',
+      async (span) => {
+        span.setAttribute('user.email', data.email);
+        const user = await this.userRepository.create(data);
+        return user;
+      },
+      { userType: 'premium' }
+    );
+  }
+}
+```
+
+### Standalone Usage (without NestJS)
+
+#### OpenTelemetry
+
+```typescript
+import { initOpenTelemetry, TracingHelper } from '@vtvlive/interactive-apm';
+import { SpanKind } from '@opentelemetry/api';
+
+// Initialize at the top of your application
+await initOpenTelemetry({
+  serviceName: 'my-service',
+  otlpEndpoint: 'http://localhost:8200/v1/traces',
+  environment: 'production',
+});
+
+// Use TracingHelper for manual tracing
+const span = TracingHelper.startSpan('operation', { key: 'value' }, SpanKind.SERVER);
+try {
+  // Your code here
+  TracingHelper.setAttribute('result', 'success');
+} catch (error) {
+  TracingHelper.captureError(error);
+  throw error;
+} finally {
+  TracingHelper.endSpan(span);
+}
+```
+
+#### Elastic APM
+
+```typescript
+import { initElasticApm, createTracingProvider, TracingService } from '@vtvlive/interactive-apm';
+
+// Initialize at the top of your application
+initElasticApm({
+  serviceName: 'my-service',
+  serverUrl: 'http://localhost:8200',
+  environment: 'production',
+});
+
+// Use TracingService
+const provider = createTracingProvider({ provider: 'elastic-apm' });
+const tracingService = new TracingService(provider);
+
+const span = tracingService.startSpan('operation', { key: 'value' });
+try {
+  // Your code here
+} catch (error) {
+  tracingService.captureError(error);
+  throw error;
+} finally {
+  span.end();
+}
+```
+
+## API Reference
+
+### TracingModule
+
+NestJS module for APM integration.
+
+| Method | Description |
+|--------|-------------|
+| `register(options)` | Register module with synchronous options |
+| `registerAsync(options)` | Register module with asynchronous options |
+
+### TracingService
+
+Service for tracing operations.
+
+| Method | Description |
+|--------|-------------|
+| `startSpan(name, attributes?, spanKind?)` | Start a new span |
+| `startSpanWithParent(name, fn, attributes?)` | Execute function with tracing context |
+| `captureError(error)` | Capture error to active span |
+| `setAttribute(key, value)` | Set attribute on active span |
+| `endSpan(span?)` | End a span |
+| `shutdown()` | Flush and shutdown provider |
+
+### TracingHelper
+
+Static utility class for OpenTelemetry.
+
+| Method | Description |
+|--------|-------------|
+| `startSpan(name, attributes?, spanKind?)` | Start a new span |
+| `startSpanWithParent(name, fn, attributes?)` | Execute function with tracing context |
+| `captureError(error)` | Capture error to active span |
+| `setAttribute(key, value)` | Set attribute on active span |
+| `endSpan(span?)` | End a span |
+| `getActiveSpan()` | Get the active span |
+| `getTraceId()` | Get the current trace ID |
+
+### SpanKind
+
+Types of spans:
+
+- `INTERNAL`: Internal operation
+- `SERVER`: Server-side request handler (API endpoints)
+- `CLIENT`: Client-side call (outgoing HTTP, database)
+- `PRODUCER`: Message producer
+- `CONSUMER`: Message consumer
+
+## Provider Selection
+
+The package supports two APM providers:
+
+### OpenTelemetry (default)
+
+Uses OpenTelemetry SDK with OTLP exporter to send traces to Elastic APM.
+
+```bash
+APM_PROVIDER=opentelemetry
+```
+
+### Elastic APM
+
+Uses the native Elastic APM Node.js agent.
+
+```bash
+APM_PROVIDER=elastic-apm
+```
+
+## Testing
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run tests with coverage
+npm run test:coverage
+
+# Run only unit tests
+npm run test:unit
+
+# Run only integration tests
+npm run test:integration
+```
+
+## Development
+
+```bash
+# Build the package
+npm run build
+
+# Build in watch mode
+npm run build:watch
+
+# Run tests
+npm test
+
+# Clean build artifacts
+npm run clean
+```
+
+**For detailed deployment instructions (build, publish, install from private registry), see [DEPLOYMENT.md](DEPLOYMENT.md)**
+
+## License
+
+MIT
+
+## Author
+
+VTVLive
+
+---
+
+For more information, visit the [Elastic APM documentation](https://www.elastic.co/guide/en/apm/get-started/current/index.html) or [OpenTelemetry documentation](https://opentelemetry.io/docs/instrumentation/js/).

package/dist/factories/tracing-provider.factory.d.ts

@@ -0,0 +1,81 @@
+import { ITracingProvider } from '../interfaces/tracing-provider.interface';
+import { ApmProvider } from '../types/apm-provider.type';
+/**
+ * Configuration options for creating a tracing provider
+ */
+export interface TracingProviderConfig {
+    /** Provider type: 'elastic-apm' or 'opentelemetry' (default: '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;
+    /** 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>;
+    /** Enable console exporter for debugging (default: false) */
+    enableConsoleExporter?: boolean;
+    /** Service version */
+    serviceVersion?: string;
+}
+/**
+ * Factory function để tạo APM Provider phù hợp dựa trên cấu hình
+ *
+ * @param config Configuration options
+ * @returns ITracingProvider instance
+ *
+ * @example
+ * // Tạo provider với config cụ thể
+ * const provider = createTracingProvider({
+ *   provider: ApmProvider.OPENTELEMETRY,
+ *   serviceName: 'my-service',
+ *   otlpEndpoint: 'http://localhost:8200/v1/traces'
+ * });
+ *
+ * @example
+ * // Tạo provider từ environment variables
+ * const provider = createTracingProvider();
+ */
+export declare function createTracingProvider(config?: TracingProviderConfig): ITracingProvider;
+/**
+ * NestJS Provider token for dependency injection
+ * Use this when integrating with NestJS
+ */
+export declare const TRACING_PROVIDER_TOKEN = "ITracingProvider";
+/**
+ * NestJS factory provider for use with NestJS dependency injection
+ *
+ * @example
+ * // Trong NestJS module
+ * import { TracingProviderFactory, TRACING_PROVIDER_TOKEN } from '@vtvlive/interactive-apm';
+ *
+ * @Module({
+ *   providers: [
+ *     {
+ *       provide: TRACING_PROVIDER_TOKEN,
+ *       useFactory: (configService: ConfigService) => {
+ *         return createTracingProvider({
+ *           provider: configService.get('APM_PROVIDER'),
+ *           serviceName: configService.get('ELASTIC_APM_SERVICE_NAME'),
+ *         });
+ *       },
+ *       inject: [ConfigService],
+ *     },
+ *   ],
+ *   exports: [TRACING_PROVIDER_TOKEN],
+ * })
+ * export class TracingModule {}
+ */
+export declare const TracingProviderFactory: {
+    provide: string;
+    useFactory: (configService?: any) => ITracingProvider;
+    inject: string[];
+};
+//# sourceMappingURL=tracing-provider.factory.d.ts.map

package/dist/factories/tracing-provider.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing-provider.factory.d.ts","sourceRoot":"","sources":["../../src/factories/tracing-provider.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAG5E,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,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,mEAAmE;IACnE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mHAAmH;IACnH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,6DAA6D;IAC7D,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,qBAA0B,GAAG,gBAAgB,CAQ1F;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,sBAAsB;;iCAEJ,GAAG;;CAgCjC,CAAC"}

package/dist/factories/tracing-provider.factory.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TracingProviderFactory = exports.TRACING_PROVIDER_TOKEN = void 0;
+exports.createTracingProvider = createTracingProvider;
+const opentelemetry_tracing_provider_1 = require("../providers/opentelemetry.tracing-provider");
+const elastic_apm_tracing_provider_1 = require("../providers/elastic-apm.tracing-provider");
+const apm_provider_type_1 = require("../types/apm-provider.type");
+/**
+ * Factory function để tạo APM Provider phù hợp dựa trên cấu hình
+ *
+ * @param config Configuration options
+ * @returns ITracingProvider instance
+ *
+ * @example
+ * // Tạo provider với config cụ thể
+ * const provider = createTracingProvider({
+ *   provider: ApmProvider.OPENTELEMETRY,
+ *   serviceName: 'my-service',
+ *   otlpEndpoint: 'http://localhost:8200/v1/traces'
+ * });
+ *
+ * @example
+ * // Tạo provider từ environment variables
+ * const provider = createTracingProvider();
+ */
+function createTracingProvider(config = {}) {
+    const provider = config.provider || process.env.APM_PROVIDER || apm_provider_type_1.ApmProvider.OPENTELEMETRY;
+    if (provider === apm_provider_type_1.ApmProvider.ELASTIC_APM || provider === 'elastic-apm') {
+        return new elastic_apm_tracing_provider_1.ElasticApmTracingProvider(config);
+    }
+    return new opentelemetry_tracing_provider_1.OpenTelemetryTracingProvider(config);
+}
+/**
+ * NestJS Provider token for dependency injection
+ * Use this when integrating with NestJS
+ */
+exports.TRACING_PROVIDER_TOKEN = 'ITracingProvider';
+/**
+ * NestJS factory provider for use with NestJS dependency injection
+ *
+ * @example
+ * // Trong NestJS module
+ * import { TracingProviderFactory, TRACING_PROVIDER_TOKEN } from '@vtvlive/interactive-apm';
+ *
+ * @Module({
+ *   providers: [
+ *     {
+ *       provide: TRACING_PROVIDER_TOKEN,
+ *       useFactory: (configService: ConfigService) => {
+ *         return createTracingProvider({
+ *           provider: configService.get('APM_PROVIDER'),
+ *           serviceName: configService.get('ELASTIC_APM_SERVICE_NAME'),
+ *         });
+ *       },
+ *       inject: [ConfigService],
+ *     },
+ *   ],
+ *   exports: [TRACING_PROVIDER_TOKEN],
+ * })
+ * export class TracingModule {}
+ */
+exports.TracingProviderFactory = {
+    provide: exports.TRACING_PROVIDER_TOKEN,
+    useFactory: (configService) => {
+        // Support both standalone and NestJS usage
+        const get = (key, defaultValue) => {
+            if (configService && typeof configService.get === 'function') {
+                return configService.get(key, defaultValue);
+            }
+            return process.env[key] || defaultValue;
+        };
+        const otlpAuthToken = get('ELASTIC_OTLP_AUTH_TOKEN', '');
+        const secretToken = get('ELASTIC_APM_SECRET_TOKEN', '');
+        // Build Authorization header if token is provided
+        const headers = {};
+        const token = otlpAuthToken || secretToken;
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        return createTracingProvider({
+            provider: get('APM_PROVIDER', 'opentelemetry'),
+            serviceName: get('ELASTIC_APM_SERVICE_NAME', 'interactive-backend'),
+            environment: get('ELASTIC_APM_ENVIRONMENT', 'development'),
+            serverUrl: get('ELASTIC_APM_SERVER_URL', 'http://localhost:8200'),
+            secretToken,
+            otlpEndpoint: get('ELASTIC_OTLP_ENDPOINT', 'http://localhost:8200/v1/traces'),
+            otlpAuthToken,
+            otlpHeaders: Object.keys(headers).length > 0 ? headers : undefined,
+            enableConsoleExporter: get('ELASTIC_OTLP_ENABLE_CONSOLE_EXPORTER', 'false') === 'true',
+        });
+    },
+    inject: ['CONFIG_SERVICE'], // Optional injection token
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { TracingModule, TracingModuleOptions, TracingModuleAsyncOptions } from './modules/tracing.module';
+export { TracingService } from './services/tracing.service';
+export { TracingHelper } from './utils/tracing.helper';
+export { ITracingProvider } from './interfaces/tracing-provider.interface';
+export { ApmProvider, SpanKind } from './types/apm-provider.type';
+export { ElasticApmTracingProvider } from './providers/elastic-apm.tracing-provider';
+export { OpenTelemetryTracingProvider } from './providers/opentelemetry.tracing-provider';
+export { createTracingProvider, TracingProviderFactory, TRACING_PROVIDER_TOKEN, TracingProviderConfig } from './factories/tracing-provider.factory';
+export { initElasticApm, isElasticApmStarted, getElasticApmAgent, shouldUseElasticApm, ElasticApmInitOptions } from './init/elastic-apm-init';
+export { initOpenTelemetry, shouldUseOpenTelemetry, OpenTelemetryInitOptions } from './init/opentelemetry-init';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAG1G,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAG5D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAGvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAG3E,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAGlE,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,EAAE,4BAA4B,EAAE,MAAM,4CAA4C,CAAC;AAG1F,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAGpJ,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,wBAAwB,EACzB,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseOpenTelemetry = exports.initOpenTelemetry = exports.shouldUseElasticApm = exports.getElasticApmAgent = exports.isElasticApmStarted = exports.initElasticApm = exports.TRACING_PROVIDER_TOKEN = exports.TracingProviderFactory = exports.createTracingProvider = exports.OpenTelemetryTracingProvider = exports.ElasticApmTracingProvider = exports.SpanKind = exports.ApmProvider = exports.TracingHelper = exports.TracingService = exports.TracingModule = void 0;
+// Core exports - NestJS integration
+var tracing_module_1 = require("./modules/tracing.module");
+Object.defineProperty(exports, "TracingModule", { enumerable: true, get: function () { return tracing_module_1.TracingModule; } });
+// Services
+var tracing_service_1 = require("./services/tracing.service");
+Object.defineProperty(exports, "TracingService", { enumerable: true, get: function () { return tracing_service_1.TracingService; } });
+// Utils - Standalone usage
+var tracing_helper_1 = require("./utils/tracing.helper");
+Object.defineProperty(exports, "TracingHelper", { enumerable: true, get: function () { return tracing_helper_1.TracingHelper; } });
+// Types
+var apm_provider_type_1 = require("./types/apm-provider.type");
+Object.defineProperty(exports, "ApmProvider", { enumerable: true, get: function () { return apm_provider_type_1.ApmProvider; } });
+Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function () { return apm_provider_type_1.SpanKind; } });
+// Providers - for direct usage
+var elastic_apm_tracing_provider_1 = require("./providers/elastic-apm.tracing-provider");
+Object.defineProperty(exports, "ElasticApmTracingProvider", { enumerable: true, get: function () { return elastic_apm_tracing_provider_1.ElasticApmTracingProvider; } });
+var opentelemetry_tracing_provider_1 = require("./providers/opentelemetry.tracing-provider");
+Object.defineProperty(exports, "OpenTelemetryTracingProvider", { enumerable: true, get: function () { return opentelemetry_tracing_provider_1.OpenTelemetryTracingProvider; } });
+// Factory
+var tracing_provider_factory_1 = require("./factories/tracing-provider.factory");
+Object.defineProperty(exports, "createTracingProvider", { enumerable: true, get: function () { return tracing_provider_factory_1.createTracingProvider; } });
+Object.defineProperty(exports, "TracingProviderFactory", { enumerable: true, get: function () { return tracing_provider_factory_1.TracingProviderFactory; } });
+Object.defineProperty(exports, "TRACING_PROVIDER_TOKEN", { enumerable: true, get: function () { return tracing_provider_factory_1.TRACING_PROVIDER_TOKEN; } });
+// Init functions - for standalone/non-NestJS usage
+var elastic_apm_init_1 = require("./init/elastic-apm-init");
+Object.defineProperty(exports, "initElasticApm", { enumerable: true, get: function () { return elastic_apm_init_1.initElasticApm; } });
+Object.defineProperty(exports, "isElasticApmStarted", { enumerable: true, get: function () { return elastic_apm_init_1.isElasticApmStarted; } });
+Object.defineProperty(exports, "getElasticApmAgent", { enumerable: true, get: function () { return elastic_apm_init_1.getElasticApmAgent; } });
+Object.defineProperty(exports, "shouldUseElasticApm", { enumerable: true, get: function () { return elastic_apm_init_1.shouldUseElasticApm; } });
+var opentelemetry_init_1 = require("./init/opentelemetry-init");
+Object.defineProperty(exports, "initOpenTelemetry", { enumerable: true, get: function () { return opentelemetry_init_1.initOpenTelemetry; } });
+Object.defineProperty(exports, "shouldUseOpenTelemetry", { enumerable: true, get: function () { return opentelemetry_init_1.shouldUseOpenTelemetry; } });

package/dist/init/elastic-apm-init.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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',
+ * });
+ */
+export interface ElasticApmInitOptions {
+    /** Service name for APM */
+    serviceName?: string;
+    /** Elastic APM server URL */
+    serverUrl?: string;
+    /** Secret token for authentication */
+    secretToken?: string;
+    /** Service version */
+    serviceVersion?: string;
+    /** Deployment environment */
+    environment?: string;
+    /** APM log level */
+    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'off';
+}
+/**
+ * Check if APM should use Elastic APM provider based on configuration
+ * @returns true if Elastic APM should be used
+ */
+export declare function shouldUseElasticApm(): boolean;
+/**
+ * Initialize Elastic APM agent for standalone usage
+ *
+ * @param options Configuration options
+ * @returns The APM agent instance
+ */
+export declare function initElasticApm(options?: ElasticApmInitOptions): any;
+/**
+ * Check if Elastic APM agent is started
+ */
+export declare function isElasticApmStarted(): boolean;
+/**
+ * Get the Elastic APM agent instance
+ */
+export declare function getElasticApmAgent(): any;
+//# sourceMappingURL=elastic-apm-init.d.ts.map

package/dist/init/elastic-apm-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elastic-apm-init.d.ts","sourceRoot":"","sources":["../../src/init/elastic-apm-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,WAAW,qBAAqB;IACpC,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6BAA6B;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sBAAsB;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,6BAA6B;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB;IACpB,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;CAClE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAG7C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,GAAG,CAuBvE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAQ7C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,GAAG,CAWxC"}