@vtvlive/interactive-apm 0.0.2 → 0.0.3

package/dist/types/otlp-transport.type.d.ts

@@ -0,0 +1,14 @@
+/**
+ * OTLP Transport Type
+ *
+ * Defines the transport protocol used for exporting traces to APM
+ * - HTTP: Uses HTTP/JSON protocol (@opentelemetry/exporter-trace-otlp-http)
+ * - GRPC: Uses gRPC/protobuf protocol (@opentelemetry/exporter-trace-otlp-grpc)
+ * - PROTO: Uses protobuf over HTTP (@opentelemetry/exporter-trace-otlp-proto) - recommended for Elastic APM
+ */
+export declare enum OtlpTransport {
+    HTTP = "http",
+    GRPC = "grpc",
+    PROTO = "proto"
+}
+//# sourceMappingURL=otlp-transport.type.d.ts.map

package/dist/types/otlp-transport.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp-transport.type.d.ts","sourceRoot":"","sources":["../../src/types/otlp-transport.type.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,oBAAY,aAAa;IACvB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;CAChB"}

package/dist/types/otlp-transport.type.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtlpTransport = void 0;
+/**
+ * OTLP Transport Type
+ *
+ * Defines the transport protocol used for exporting traces to APM
+ * - HTTP: Uses HTTP/JSON protocol (@opentelemetry/exporter-trace-otlp-http)
+ * - GRPC: Uses gRPC/protobuf protocol (@opentelemetry/exporter-trace-otlp-grpc)
+ * - PROTO: Uses protobuf over HTTP (@opentelemetry/exporter-trace-otlp-proto) - recommended for Elastic APM
+ */
+var OtlpTransport;
+(function (OtlpTransport) {
+    OtlpTransport["HTTP"] = "http";
+    OtlpTransport["GRPC"] = "grpc";
+    OtlpTransport["PROTO"] = "proto";
+})(OtlpTransport || (exports.OtlpTransport = OtlpTransport = {}));

package/dist/utils/debug-exporter-wrapper.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Debug Exporter Wrapper for OpenTelemetry OTLP
+ *
+ * Wraps the OTLPTraceExporter to log full request/response details
+ * when APM_DEBUG=true. This helps debug connection issues with APM servers.
+ */
+/**
+ * Wrap OTLPTraceExporter with debug logging
+ *
+ * This intercepts the export calls to log:
+ * - Outgoing request details (URL, headers, body)
+ * - Response details (status code, headers, body)
+ * - Success/failure of exports
+ *
+ * @param baseExporter The original OTLPTraceExporter instance
+ * @param endpointUrl The OTLP endpoint URL for logging
+ * @returns Wrapped exporter with debug capabilities
+ */
+export declare function createDebugExporter(baseExporter: any, endpointUrl: string): any;
+/**
+ * Create an HTTP interceptor for more detailed debugging
+ * This can be used to intercept the actual HTTP requests made by OTLP exporter
+ */
+export declare function createHttpRequestInterceptor(): any;
+//# sourceMappingURL=debug-exporter-wrapper.d.ts.map

package/dist/utils/debug-exporter-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-exporter-wrapper.d.ts","sourceRoot":"","sources":["../../src/utils/debug-exporter-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAG,GAAG,CA6E/E;AAyBD;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,GAAG,CA4FlD"}

package/dist/utils/debug-exporter-wrapper.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * Debug Exporter Wrapper for OpenTelemetry OTLP
+ *
+ * Wraps the OTLPTraceExporter to log full request/response details
+ * when APM_DEBUG=true. This helps debug connection issues with APM servers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDebugExporter = createDebugExporter;
+exports.createHttpRequestInterceptor = createHttpRequestInterceptor;
+const debug_logger_1 = require("./debug-logger");
+/**
+ * Wrap OTLPTraceExporter with debug logging
+ *
+ * This intercepts the export calls to log:
+ * - Outgoing request details (URL, headers, body)
+ * - Response details (status code, headers, body)
+ * - Success/failure of exports
+ *
+ * @param baseExporter The original OTLPTraceExporter instance
+ * @param endpointUrl The OTLP endpoint URL for logging
+ * @returns Wrapped exporter with debug capabilities
+ */
+function createDebugExporter(baseExporter, endpointUrl) {
+    if (!(0, debug_logger_1.isDebugEnabled)()) {
+        // When debug is off, just log errors only
+        return {
+            export: (spans, resultCallback) => {
+                baseExporter.export(spans, (result) => {
+                    if (result.error) {
+                        (0, debug_logger_1.logExportFailure)('OpenTelemetry', result.error);
+                    }
+                    resultCallback(result);
+                });
+            },
+            shutdown: async () => {
+                await baseExporter.shutdown();
+            },
+            forceFlush: async () => {
+                if (baseExporter.forceFlush) {
+                    await baseExporter.forceFlush();
+                }
+            },
+        };
+    }
+    // Debug mode ON - intercept everything
+    const wrappedExporter = {
+        export: (spans, resultCallback) => {
+            const startTime = Date.now();
+            // Log what we're about to send
+            (0, debug_logger_1.logRequest)('OpenTelemetry', endpointUrl, getExporterHeaders(baseExporter), {
+                spanCount: spans.length,
+                spans: spans.map((s) => ({
+                    name: s.name,
+                    kind: s.kind,
+                    startTime: s.startTime,
+                    endTime: s.endTime,
+                })),
+            });
+            // Wrap the result callback to capture response
+            baseExporter.export(spans, (result) => {
+                const duration = Date.now() - startTime;
+                if (result.error) {
+                    (0, debug_logger_1.logExportFailure)('OpenTelemetry', result.error, {
+                        endpoint: endpointUrl,
+                        spanCount: spans.length,
+                        duration: `${duration}ms`,
+                    });
+                }
+                else {
+                    (0, debug_logger_1.logExportSuccess)('OpenTelemetry', spans.length);
+                    (0, debug_logger_1.logResponse)('OpenTelemetry', 200, { 'content-type': 'application/json' }, {
+                        message: `Exported ${spans.length} span(s) in ${duration}ms`,
+                    });
+                }
+                resultCallback(result);
+            });
+        },
+        shutdown: async () => {
+            (0, debug_logger_1.logRequest)('OpenTelemetry', endpointUrl, {}, { action: 'shutdown' });
+            try {
+                await baseExporter.shutdown();
+                (0, debug_logger_1.logResponse)('OpenTelemetry', 200, {}, { message: 'Exporter shutdown complete' });
+            }
+            catch (err) {
+                (0, debug_logger_1.logResponse)('OpenTelemetry', 500, {}, { message: 'Exporter shutdown failed', error: err?.message || err });
+                throw err;
+            }
+        },
+        forceFlush: async () => {
+            if (baseExporter.forceFlush) {
+                await baseExporter.forceFlush();
+            }
+        },
+    };
+    return wrappedExporter;
+}
+/**
+ * Get headers from the exporter instance for logging
+ * The OTLPTraceExporter stores headers internally, we need to extract them
+ */
+function getExporterHeaders(exporter) {
+    try {
+        // Try to access headers from the exporter
+        // @ts-ignore - accessing internal property
+        if (exporter._headers) {
+            // @ts-ignore
+            return { ...exporter._headers };
+        }
+        // @ts-ignore - alternative internal property
+        if (exporter.headers) {
+            // @ts-ignore
+            return { ...exporter.headers };
+        }
+    }
+    catch (error) {
+        // Silently fail if we can't access headers
+    }
+    return {};
+}
+/**
+ * Create an HTTP interceptor for more detailed debugging
+ * This can be used to intercept the actual HTTP requests made by OTLP exporter
+ */
+function createHttpRequestInterceptor() {
+    if (!(0, debug_logger_1.isDebugEnabled)()) {
+        return null;
+    }
+    const originalRequest = require('http').request;
+    const originalHttpsRequest = require('https').request;
+    return {
+        install: () => {
+            const { logRequest: logReq, logResponse: logResp } = require('./debug-logger');
+            // Override http.request
+            require('http').request = function (options, ...args) {
+                const url = typeof options === 'string' ? options : `${options.protocol || 'http:'}//${options.hostname || options.host}${options.path || '/'}`;
+                // Only intercept APM-related requests
+                if (url.includes('/v1/traces') || url.includes('/v1/metrics') || url.includes('/intake/v2/traces')) {
+                    const req = originalRequest.call(this, options, ...args);
+                    const originalWrite = req.write.bind(req);
+                    req.write = function (chunk, ...rest) {
+                        // Handle binary data safely - don't stringify protobuf/binary payloads
+                        let logData;
+                        if (Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {
+                            logData = `<binary data: ${chunk.length} bytes>`;
+                        }
+                        else if (typeof chunk === 'string') {
+                            logData = chunk;
+                        }
+                        else {
+                            logData = chunk?.toString();
+                        }
+                        logReq('OpenTelemetry', url, options.headers || {}, logData);
+                        return originalWrite(chunk, ...rest);
+                    };
+                    req.on('response', (res) => {
+                        let body = '';
+                        res.on('data', (chunk) => { body += chunk; });
+                        res.on('end', () => {
+                            logResp('OpenTelemetry', res.statusCode, res.headers, body);
+                        });
+                    });
+                    return req;
+                }
+                return originalRequest.call(this, options, ...args);
+            };
+            // Override https.request
+            require('https').request = function (options, ...args) {
+                const url = typeof options === 'string' ? options : `${options.protocol || 'https:'}//${options.hostname || options.host}${options.path || '/'}`;
+                // Only intercept APM-related requests
+                if (url.includes('/v1/traces') || url.includes('/v1/metrics') || url.includes('/intake/v2/traces')) {
+                    const req = originalHttpsRequest.call(this, options, ...args);
+                    const originalWrite = req.write.bind(req);
+                    req.write = function (chunk, ...rest) {
+                        // Handle binary data safely - don't stringify protobuf/binary payloads
+                        let logData;
+                        if (Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {
+                            logData = `<binary data: ${chunk.length} bytes>`;
+                        }
+                        else if (typeof chunk === 'string') {
+                            logData = chunk;
+                        }
+                        else {
+                            logData = chunk?.toString();
+                        }
+                        logReq('OpenTelemetry', url, options.headers || {}, logData);
+                        return originalWrite(chunk, ...rest);
+                    };
+                    req.on('response', (res) => {
+                        let body = '';
+                        res.on('data', (chunk) => { body += chunk; });
+                        res.on('end', () => {
+                            logResp('OpenTelemetry', res.statusCode, res.headers, body);
+                        });
+                    });
+                    return req;
+                }
+                return originalHttpsRequest.call(this, options, ...args);
+            };
+        },
+        uninstall: () => {
+            // Restore original functions
+            require('http').request = originalRequest;
+            require('https').request = originalHttpsRequest;
+        },
+    };
+}

package/dist/utils/debug-logger.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Debug Logger for APM Package
+ *
+ * Provides centralized debug logging that only outputs when APM_DEBUG=true.
+ * Used by both Elastic APM and OpenTelemetry providers.
+ */
+/**
+ * Check if debug mode is enabled via environment variable
+ */
+export declare function isDebugEnabled(): boolean;
+/**
+ * Sanitize headers for logging (mask sensitive values)
+ */
+export declare function sanitizeHeaders(headers: Record<string, string>): Record<string, string>;
+/**
+ * Sanitize config object for logging (mask sensitive values)
+ * Handles arrays and circular references safely
+ */
+export declare function sanitizeConfig(config: any, seen?: WeakMap<object, any>): any;
+/**
+ * Debug log - only outputs when APM_DEBUG=true
+ */
+export declare function debugLog(message: string, ...args: any[]): void;
+/**
+ * Info log - always outputs
+ */
+export declare function infoLog(message: string, ...args: any[]): void;
+/**
+ * Error log - always outputs
+ */
+export declare function errorLog(message: string, ...args: any[]): void;
+/**
+ * Log initialization details
+ */
+export declare function logInitialization(provider: string, config: Record<string, any>): void;
+/**
+ * Log span export success (debug mode only)
+ */
+export declare function logExportSuccess(provider: string, spanCount: number): void;
+/**
+ * Log span export failure - ALWAYS logs regardless of debug mode
+ */
+export declare function logExportFailure(provider: string, error: any, requestDetails?: any): void;
+/**
+ * Log outgoing HTTP request (for debugging APM communication)
+ */
+export declare function logRequest(provider: string, url: string, headers: Record<string, string>, body?: any): void;
+/**
+ * Log incoming HTTP response (for debugging APM communication)
+ */
+export declare function logResponse(provider: string, statusCode: number, headers: Record<string, string>, body?: any): void;
+/**
+ * Log span details (when debug mode is on)
+ */
+export declare function logSpan(provider: string, span: any): void;
+//# sourceMappingURL=debug-logger.d.ts.map

package/dist/utils/debug-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-logger.d.ts","sourceRoot":"","sources":["../../src/utils/debug-logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAgBD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMvF;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,GAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAiB,GAAG,GAAG,CA8C3F;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAI9D;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAE7D;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAE9D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAsBrF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAI1E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,cAAc,CAAC,EAAE,GAAG,GAAG,IAAI,CAQzF;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAwB3G;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAUnH;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI,CAmBzD"}

package/dist/utils/debug-logger.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Debug Logger for APM Package
+ *
+ * Provides centralized debug logging that only outputs when APM_DEBUG=true.
+ * Used by both Elastic APM and OpenTelemetry providers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDebugEnabled = isDebugEnabled;
+exports.sanitizeHeaders = sanitizeHeaders;
+exports.sanitizeConfig = sanitizeConfig;
+exports.debugLog = debugLog;
+exports.infoLog = infoLog;
+exports.errorLog = errorLog;
+exports.logInitialization = logInitialization;
+exports.logExportSuccess = logExportSuccess;
+exports.logExportFailure = logExportFailure;
+exports.logRequest = logRequest;
+exports.logResponse = logResponse;
+exports.logSpan = logSpan;
+/**
+ * Check if debug mode is enabled via environment variable
+ */
+function isDebugEnabled() {
+    return process.env.APM_DEBUG === 'true';
+}
+/**
+ * Mask sensitive values in headers and config for logging
+ */
+function maskSensitive(value, key) {
+    const sensitiveKeys = ['authorization', 'token', 'secret', 'password', 'apikey', 'api-key', 'x-api-key'];
+    const lowerKey = key.toLowerCase();
+    if (sensitiveKeys.some(k => lowerKey.includes(k))) {
+        return '[REDACTED]';
+    }
+    return value;
+}
+/**
+ * Sanitize headers for logging (mask sensitive values)
+ */
+function sanitizeHeaders(headers) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(headers)) {
+        sanitized[key] = maskSensitive(value, key);
+    }
+    return sanitized;
+}
+/**
+ * Sanitize config object for logging (mask sensitive values)
+ * Handles arrays and circular references safely
+ */
+function sanitizeConfig(config, seen = new WeakMap()) {
+    // Handle primitives and null
+    if (config === null || typeof config !== 'object') {
+        return config;
+    }
+    // Handle circular references
+    if (seen.has(config)) {
+        return '[Circular]';
+    }
+    seen.set(config, '[Circular]');
+    // Handle arrays
+    if (Array.isArray(config)) {
+        return config.map(item => {
+            if (typeof item === 'string') {
+                return maskSensitive(item, '');
+            }
+            else if (typeof item === 'object' && item !== null) {
+                return sanitizeConfig(item, seen);
+            }
+            return item;
+        });
+    }
+    // Handle objects
+    const sanitized = {};
+    for (const [key, value] of Object.entries(config)) {
+        if (typeof value === 'string') {
+            sanitized[key] = maskSensitive(value, key);
+        }
+        else if (Array.isArray(value)) {
+            sanitized[key] = value.map(item => {
+                if (typeof item === 'string') {
+                    return maskSensitive(item, key);
+                }
+                else if (typeof item === 'object' && item !== null) {
+                    return sanitizeConfig(item, seen);
+                }
+                return item;
+            });
+        }
+        else if (typeof value === 'object' && value !== null) {
+            sanitized[key] = sanitizeConfig(value, seen);
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}
+/**
+ * Debug log - only outputs when APM_DEBUG=true
+ */
+function debugLog(message, ...args) {
+    if (isDebugEnabled()) {
+        console.log(`[APM-DEBUG] ${message}`, ...args);
+    }
+}
+/**
+ * Info log - always outputs
+ */
+function infoLog(message, ...args) {
+    console.log(`[APM] ${message}`, ...args);
+}
+/**
+ * Error log - always outputs
+ */
+function errorLog(message, ...args) {
+    console.error(`[APM-ERROR] ${message}`, ...args);
+}
+/**
+ * Log initialization details
+ */
+function logInitialization(provider, config) {
+    if (!isDebugEnabled()) {
+        return;
+    }
+    debugLog(`=== ${provider} Initialization ===`);
+    debugLog('Configuration:', sanitizeConfig(config));
+    debugLog('Environment Variables:', {
+        APM_PROVIDER: process.env.APM_PROVIDER,
+        ELASTIC_APM_SERVICE_NAME: process.env.ELASTIC_APM_SERVICE_NAME,
+        ELASTIC_APM_ENVIRONMENT: process.env.ELASTIC_APM_ENVIRONMENT,
+        ELASTIC_OTLP_ENDPOINT: process.env.ELASTIC_OTLP_ENDPOINT,
+        ELASTIC_APM_SERVER_URL: process.env.ELASTIC_APM_SERVER_URL,
+        APM_DEBUG: process.env.APM_DEBUG,
+    });
+    debugLog('System Info:', {
+        nodeVersion: process.version,
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        hostname: require('os').hostname(),
+    });
+}
+/**
+ * Log span export success (debug mode only)
+ */
+function logExportSuccess(provider, spanCount) {
+    if (isDebugEnabled()) {
+        debugLog(`[${provider}] Exported ${spanCount} span(s)`);
+    }
+}
+/**
+ * Log span export failure - ALWAYS logs regardless of debug mode
+ */
+function logExportFailure(provider, error, requestDetails) {
+    // Always log export failures as errors
+    errorLog(`[${provider}] Export failed:`, error);
+    // Log additional details only in debug mode
+    if (isDebugEnabled() && requestDetails) {
+        debugLog('Request details:', sanitizeConfig(requestDetails));
+    }
+}
+/**
+ * Log outgoing HTTP request (for debugging APM communication)
+ */
+function logRequest(provider, url, headers, body) {
+    if (!isDebugEnabled()) {
+        return;
+    }
+    debugLog(`[${provider}] → Sending request to: ${url}`);
+    debugLog('Headers:', sanitizeHeaders(headers));
+    // Sanitize request body for sensitive data before logging
+    if (body) {
+        // WARNING: Request bodies may contain sensitive data - we sanitize common patterns
+        let sanitizedBody;
+        if (typeof body === 'string') {
+            // Redact common auth/token patterns in strings
+            sanitizedBody = body.replace(/"(?:password|pass|pwd|token|access_token|auth|authorization|cookie|ssn|creditCard|cardNumber|cvv|secret)"\s*:\s*"[^"]*"/gi, '"$1": "[REDACTED]"');
+            sanitizedBody = sanitizedBody.replace(/Bearer\s+[A-Za-z0-9\-._~+/=]*/gi, 'Bearer [REDACTED]');
+        }
+        else if (typeof body === 'object' && body !== null) {
+            // Deep clone and sanitize object
+            sanitizedBody = sanitizeConfig(body);
+        }
+        else {
+            sanitizedBody = body;
+        }
+        debugLog('Body:', typeof sanitizedBody === 'string' ? sanitizedBody : JSON.stringify(sanitizedBody, null, 2));
+    }
+}
+/**
+ * Log incoming HTTP response (for debugging APM communication)
+ */
+function logResponse(provider, statusCode, headers, body) {
+    if (!isDebugEnabled()) {
+        return;
+    }
+    debugLog(`[${provider}] ← Received response: ${statusCode}`);
+    debugLog('Response Headers:', sanitizeHeaders(headers));
+    if (body) {
+        debugLog('Response Body:', typeof body === 'string' ? body : JSON.stringify(body, null, 2));
+    }
+}
+/**
+ * Log span details (when debug mode is on)
+ */
+function logSpan(provider, span) {
+    if (!isDebugEnabled()) {
+        return;
+    }
+    try {
+        const spanDetails = {
+            name: span.name,
+            kind: span.kind,
+            startTime: span.startTime,
+            endTime: span.endTime,
+            duration: span.endTime - span.startTime,
+            attributes: span.attributes,
+            status: span.status,
+        };
+        debugLog(`[${provider}] Span details:`, JSON.stringify(spanDetails, null, 2));
+    }
+    catch (error) {
+        debugLog(`[${provider}] Could not serialize span:`, error);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtvlive/interactive-apm",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "APM integration package supporting both Elastic APM and OpenTelemetry with NestJS integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,6 +35,8 @@
     "@nestjs/config": "^1.0.0 || ^2.0.0 || ^3.0.0 || ^4.0.0",
     "@opentelemetry/api": "^1.0.0",
     "@opentelemetry/exporter-trace-otlp-http": ">=0.200.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": ">=0.200.0",
+    "@opentelemetry/exporter-trace-otlp-proto": ">=0.200.0",
     "@opentelemetry/instrumentation-express": ">=0.50.0",
     "@opentelemetry/instrumentation-http": ">=0.200.0",
     "@opentelemetry/resources": ">=1.0.0",
@@ -56,6 +58,12 @@
     "@opentelemetry/exporter-trace-otlp-http": {
       "optional": true
     },
+    "@opentelemetry/exporter-trace-otlp-grpc": {
+      "optional": true
+    },
+    "@opentelemetry/exporter-trace-otlp-proto": {
+      "optional": true
+    },
     "@opentelemetry/instrumentation-express": {
       "optional": true
     },
@@ -83,6 +91,8 @@
     "@nestjs/config": "^4.0.3",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.213.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^1.22.0",
     "@opentelemetry/instrumentation-express": "^0.61.0",
     "@opentelemetry/instrumentation-http": "^0.213.0",
     "@opentelemetry/resources": "^2.6.0",