@vfarcic/dot-ai 0.125.0 → 0.127.0

package/dist/core/tracing/ai-tracing.d.ts

@@ -0,0 +1,80 @@
+/**
+ * AI Provider Tracing Utilities
+ *
+ * Generic wrapper for instrumenting AI provider calls with OpenTelemetry.
+ * Uses official GenAI semantic conventions for AI/LLM operations.
+ *
+ * Supports:
+ * - chat operations (sendMessage)
+ * - tool_loop operations (toolLoop with agentic tool calling)
+ * - embeddings operations (generateEmbedding, generateEmbeddings)
+ *
+ * Reference: https://opentelemetry.io/docs/specs/semconv/gen-ai/
+ */
+/**
+ * Configuration for AI operation tracing
+ */
+export interface AITracingOptions {
+    /** AI provider name (e.g., 'anthropic', 'openai', 'google') */
+    provider: string;
+    /** Model identifier (e.g., 'claude-3-5-sonnet', 'gpt-4o', 'text-embedding-3-small') */
+    model: string;
+    /** Operation type: 'chat', 'tool_loop', 'embeddings' */
+    operation: 'chat' | 'tool_loop' | 'embeddings';
+    /** Optional max tokens parameter (only for chat/tool_loop operations) */
+    maxTokens?: number;
+}
+/**
+ * Metrics extracted from AI operation result
+ * Fields vary by operation type:
+ * - chat/tool_loop: inputTokens, outputTokens, cache tokens
+ * - embeddings: embeddingCount, embeddingDimensions
+ */
+export interface AITracingResult {
+    /** Input tokens consumed (chat/tool_loop only) */
+    inputTokens?: number;
+    /** Output tokens generated (chat/tool_loop only) */
+    outputTokens?: number;
+    /** Cache read tokens (if provider supports caching) */
+    cacheReadTokens?: number;
+    /** Cache creation tokens (if provider supports caching) */
+    cacheCreationTokens?: number;
+    /** Number of embeddings generated (embeddings only) */
+    embeddingCount?: number;
+    /** Dimension size of embeddings (embeddings only) */
+    embeddingDimensions?: number;
+}
+/**
+ * Generic wrapper for AI provider calls
+ *
+ * Creates CLIENT spans with official gen_ai.* semantic conventions.
+ * The auto-instrumented HTTP span becomes a child of this span.
+ *
+ * @param options AI operation configuration
+ * @param handler Function that performs the actual AI call
+ * @param extractMetrics Function to extract metrics from the result
+ * @returns Result from the handler function
+ *
+ * @example Chat operation
+ * const response = await withAITracing(
+ *   { provider: 'anthropic', model: 'claude-3-5-sonnet', operation: 'chat' },
+ *   async () => await client.messages.create(...),
+ *   (result) => ({ inputTokens: result.usage.input_tokens, outputTokens: result.usage.output_tokens })
+ * );
+ *
+ * @example Tool loop operation
+ * const result = await withAITracing(
+ *   { provider: 'anthropic', model: 'claude-3-5-sonnet', operation: 'tool_loop' },
+ *   async () => await provider.toolLoop(...),
+ *   (result) => ({ inputTokens: result.totalTokens.input, outputTokens: result.totalTokens.output })
+ * );
+ *
+ * @example Embeddings operation
+ * const embedding = await withAITracing(
+ *   { provider: 'openai', model: 'text-embedding-3-small', operation: 'embeddings' },
+ *   async () => await client.embeddings.create(...),
+ *   (result) => ({ embeddingCount: 1, embeddingDimensions: 1536 })
+ * );
+ */
+export declare function withAITracing<T>(options: AITracingOptions, handler: () => Promise<T>, extractMetrics: (result: T) => AITracingResult): Promise<T>;
+//# sourceMappingURL=ai-tracing.d.ts.map

package/dist/core/tracing/ai-tracing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tracing.d.ts","sourceRoot":"","sources":["../../../src/core/tracing/ai-tracing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IAEjB,uFAAuF;IACvF,KAAK,EAAE,MAAM,CAAC;IAEd,wDAAwD;IACxD,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,YAAY,CAAC;IAE/C,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,2DAA2D;IAC3D,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B,uDAAuD;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,qDAAqD;IACrD,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,cAAc,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,eAAe,GAC7C,OAAO,CAAC,CAAC,CAAC,CAwFZ"}

package/dist/core/tracing/ai-tracing.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * AI Provider Tracing Utilities
+ *
+ * Generic wrapper for instrumenting AI provider calls with OpenTelemetry.
+ * Uses official GenAI semantic conventions for AI/LLM operations.
+ *
+ * Supports:
+ * - chat operations (sendMessage)
+ * - tool_loop operations (toolLoop with agentic tool calling)
+ * - embeddings operations (generateEmbedding, generateEmbeddings)
+ *
+ * Reference: https://opentelemetry.io/docs/specs/semconv/gen-ai/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAITracing = withAITracing;
+const api_1 = require("@opentelemetry/api");
+/**
+ * Generic wrapper for AI provider calls
+ *
+ * Creates CLIENT spans with official gen_ai.* semantic conventions.
+ * The auto-instrumented HTTP span becomes a child of this span.
+ *
+ * @param options AI operation configuration
+ * @param handler Function that performs the actual AI call
+ * @param extractMetrics Function to extract metrics from the result
+ * @returns Result from the handler function
+ *
+ * @example Chat operation
+ * const response = await withAITracing(
+ *   { provider: 'anthropic', model: 'claude-3-5-sonnet', operation: 'chat' },
+ *   async () => await client.messages.create(...),
+ *   (result) => ({ inputTokens: result.usage.input_tokens, outputTokens: result.usage.output_tokens })
+ * );
+ *
+ * @example Tool loop operation
+ * const result = await withAITracing(
+ *   { provider: 'anthropic', model: 'claude-3-5-sonnet', operation: 'tool_loop' },
+ *   async () => await provider.toolLoop(...),
+ *   (result) => ({ inputTokens: result.totalTokens.input, outputTokens: result.totalTokens.output })
+ * );
+ *
+ * @example Embeddings operation
+ * const embedding = await withAITracing(
+ *   { provider: 'openai', model: 'text-embedding-3-small', operation: 'embeddings' },
+ *   async () => await client.embeddings.create(...),
+ *   (result) => ({ embeddingCount: 1, embeddingDimensions: 1536 })
+ * );
+ */
+async function withAITracing(options, handler, extractMetrics) {
+    // Get tracer (returns no-op if tracing disabled)
+    const tracer = api_1.trace.getTracer('dot-ai-mcp');
+    // Span name format: "{operation} {model}"
+    // Examples: "chat claude-3-5-sonnet", "tool_loop claude-3-5-sonnet", "embeddings text-embedding-3-small"
+    const spanName = `${options.operation} ${options.model}`;
+    return await tracer.startActiveSpan(spanName, {
+        kind: api_1.SpanKind.CLIENT,
+        attributes: {
+            // Required GenAI attributes (per OpenTelemetry spec)
+            'gen_ai.operation.name': options.operation,
+            'gen_ai.provider.name': options.provider,
+            'gen_ai.request.model': options.model,
+            // Optional request parameters (only for chat/tool_loop)
+            ...(options.maxTokens !== undefined && {
+                'gen_ai.request.max_tokens': options.maxTokens,
+            }),
+        },
+    }, async (span) => {
+        const startTime = Date.now();
+        try {
+            // Execute the actual AI call within this span's context
+            // Auto-instrumented HTTP spans will be children of this span
+            const result = await api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), handler);
+            // Extract metrics from the result
+            const metrics = extractMetrics(result);
+            // Add response model (usually same as request)
+            span.setAttribute('gen_ai.response.model', options.model);
+            span.setAttribute('gen_ai.ai.duration_ms', Date.now() - startTime);
+            // Add operation-specific metrics
+            if (options.operation === 'chat' || options.operation === 'tool_loop') {
+                // Token-based metrics for chat/tool_loop operations
+                if (metrics.inputTokens !== undefined) {
+                    span.setAttribute('gen_ai.usage.input_tokens', metrics.inputTokens);
+                }
+                if (metrics.outputTokens !== undefined) {
+                    span.setAttribute('gen_ai.usage.output_tokens', metrics.outputTokens);
+                }
+                // Cache metrics (Anthropic-specific for chat operations)
+                if (metrics.cacheReadTokens !== undefined && metrics.cacheReadTokens > 0) {
+                    span.setAttribute('gen_ai.usage.cache_read_tokens', metrics.cacheReadTokens);
+                }
+                if (metrics.cacheCreationTokens !== undefined && metrics.cacheCreationTokens > 0) {
+                    span.setAttribute('gen_ai.usage.cache_creation_tokens', metrics.cacheCreationTokens);
+                }
+            }
+            else if (options.operation === 'embeddings') {
+                // Embedding-specific metrics
+                if (metrics.embeddingCount !== undefined) {
+                    span.setAttribute('gen_ai.embeddings.count', metrics.embeddingCount);
+                }
+                if (metrics.embeddingDimensions !== undefined) {
+                    span.setAttribute('gen_ai.embeddings.dimensions', metrics.embeddingDimensions);
+                }
+            }
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            // Record exception with full details
+            span.recordException(error);
+            span.setStatus({
+                code: api_1.SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            span.setAttribute('error.type', error instanceof Error ? error.constructor.name : 'unknown');
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    });
+}

package/dist/core/tracing/config.d.ts

@@ -0,0 +1,15 @@
+/**
+ * OpenTelemetry Tracing Configuration
+ *
+ * Manages tracing configuration from environment variables with sensible defaults.
+ */
+import { TracingConfig } from './types';
+/**
+ * Load tracing configuration from environment variables
+ */
+export declare function loadTracingConfig(): TracingConfig;
+/**
+ * Validate tracing configuration
+ */
+export declare function validateTracingConfig(config: TracingConfig): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/tracing/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/core/tracing/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AA8FxC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,aAAa,CAwBjD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAejE"}

package/dist/core/tracing/config.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * OpenTelemetry Tracing Configuration
+ *
+ * Manages tracing configuration from environment variables with sensible defaults.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTracingConfig = loadTracingConfig;
+exports.validateTracingConfig = validateTracingConfig;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+/**
+ * Load service version from package.json
+ */
+function getServiceVersion() {
+    try {
+        const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+        const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf8'));
+        return packageJson.version || '0.0.0';
+    }
+    catch (error) {
+        console.error('Failed to load service version from package.json:', error);
+        return '0.0.0';
+    }
+}
+/**
+ * Determine exporter type from environment variables
+ */
+function getExporterType() {
+    const exporterEnv = process.env.OTEL_EXPORTER_TYPE?.toLowerCase();
+    // Check for OTLP endpoint - if set, use OTLP exporter
+    if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+        return 'otlp';
+    }
+    // Explicit exporter type
+    switch (exporterEnv) {
+        case 'otlp':
+            return 'otlp';
+        case 'jaeger':
+            return 'jaeger';
+        case 'zipkin':
+            return 'zipkin';
+        case 'console':
+            return 'console';
+        default:
+            // Default to console for local development (zero-config)
+            return 'console';
+    }
+}
+/**
+ * Get sampling probability from environment
+ */
+function getSamplingProbability() {
+    const samplingEnv = process.env.OTEL_SAMPLING_PROBABILITY;
+    if (!samplingEnv) {
+        return 1.0; // Always-on sampling by default
+    }
+    const probability = parseFloat(samplingEnv);
+    if (isNaN(probability) || probability < 0 || probability > 1) {
+        console.warn(`Invalid OTEL_SAMPLING_PROBABILITY: ${samplingEnv}, using 1.0`);
+        return 1.0;
+    }
+    return probability;
+}
+/**
+ * Check if tracing is enabled
+ *
+ * Default: disabled to avoid console noise.
+ * Users can enable with OTEL_TRACING_ENABLED=true when they want observability.
+ */
+function isTracingEnabled() {
+    const enabledEnv = process.env.OTEL_TRACING_ENABLED?.toLowerCase();
+    // Explicit enable
+    if (enabledEnv === 'true' || enabledEnv === '1' || enabledEnv === 'yes') {
+        return true;
+    }
+    // Explicit disable
+    if (enabledEnv === 'false' || enabledEnv === '0' || enabledEnv === 'no') {
+        return false;
+    }
+    // Default: disabled to keep logs clean
+    return false;
+}
+/**
+ * Check if debug mode is enabled
+ */
+function isDebugMode() {
+    const debugEnv = process.env.OTEL_DEBUG?.toLowerCase();
+    return debugEnv === 'true' || debugEnv === '1' || debugEnv === 'yes';
+}
+/**
+ * Load tracing configuration from environment variables
+ */
+function loadTracingConfig() {
+    const config = {
+        serviceName: process.env.OTEL_SERVICE_NAME || 'dot-ai-mcp',
+        serviceVersion: getServiceVersion(),
+        exporterType: getExporterType(),
+        otlpEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+        enabled: isTracingEnabled(),
+        samplingProbability: getSamplingProbability(),
+        debug: isDebugMode()
+    };
+    // Log configuration in debug mode
+    if (config.debug) {
+        console.log('[Tracing] Configuration loaded:', {
+            serviceName: config.serviceName,
+            serviceVersion: config.serviceVersion,
+            exporterType: config.exporterType,
+            otlpEndpoint: config.otlpEndpoint,
+            enabled: config.enabled,
+            samplingProbability: config.samplingProbability
+        });
+    }
+    return config;
+}
+/**
+ * Validate tracing configuration
+ */
+function validateTracingConfig(config) {
+    // Validate OTLP endpoint if OTLP exporter is selected
+    if (config.exporterType === 'otlp' && !config.otlpEndpoint) {
+        throw new Error('OTLP exporter requires OTEL_EXPORTER_OTLP_ENDPOINT environment variable');
+    }
+    // Warn about production configurations
+    if (config.exporterType === 'console' && process.env.NODE_ENV === 'production') {
+        console.warn('[Tracing] Warning: Using console exporter in production. ' +
+            'Consider using OTLP, Jaeger, or Zipkin exporter for production deployments.');
+    }
+}

package/dist/core/tracing/http-tracing.d.ts

@@ -0,0 +1,28 @@
+/**
+ * HTTP Server Tracing Module
+ *
+ * Provides manual SERVER span creation for incoming HTTP requests.
+ * Follows OpenTelemetry HTTP semantic conventions.
+ */
+import { Span } from '@opentelemetry/api';
+import { IncomingMessage, ServerResponse } from 'node:http';
+/**
+ * Create and manage HTTP SERVER span for incoming request
+ *
+ * Returns a function to end the span with response status code
+ */
+export declare function createHttpServerSpan(req: IncomingMessage): {
+    span: Span;
+    endSpan: (statusCode: number) => void;
+};
+/**
+ * Wrap HTTP request handler with tracing
+ *
+ * This is a higher-order function that wraps an existing HTTP request handler
+ * with automatic SERVER span creation and management.
+ *
+ * @param handler - Original HTTP request handler
+ * @returns Wrapped handler with tracing
+ */
+export declare function withHttpServerTracing(handler: (req: IncomingMessage, res: ServerResponse) => Promise<void>): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+//# sourceMappingURL=http-tracing.d.ts.map

package/dist/core/tracing/http-tracing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-tracing.d.ts","sourceRoot":"","sources":["../../../src/core/tracing/http-tracing.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAML,IAAI,EACL,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAiE5D;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,eAAe,GACnB;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,CAyCvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,GACpE,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAwB9D"}

package/dist/core/tracing/http-tracing.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * HTTP Server Tracing Module
+ *
+ * Provides manual SERVER span creation for incoming HTTP requests.
+ * Follows OpenTelemetry HTTP semantic conventions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpServerSpan = createHttpServerSpan;
+exports.withHttpServerTracing = withHttpServerTracing;
+const api_1 = require("@opentelemetry/api");
+/**
+ * Extract trace context from HTTP headers
+ * Follows W3C Trace Context specification
+ */
+function extractTraceContext(req) {
+    return api_1.propagation.extract(api_1.context.active(), req.headers);
+}
+/**
+ * Build span attributes from HTTP request
+ */
+function buildSpanAttributes(req) {
+    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+    const attributes = {
+        'http.request.method': req.method || 'UNKNOWN',
+        'url.path': url.pathname,
+        'url.scheme': url.protocol.replace(':', ''),
+        'http.route': url.pathname, // Can be enhanced with route templates
+    };
+    // Add optional attributes
+    if (req.headers.host) {
+        const [hostname, port] = req.headers.host.split(':');
+        attributes['server.address'] = hostname;
+        if (port) {
+            attributes['server.port'] = parseInt(port, 10);
+        }
+    }
+    // Client address (from headers or socket)
+    const clientAddress = req.headers['x-forwarded-for']?.split(',')[0]?.trim() ||
+        req.socket.remoteAddress;
+    if (clientAddress) {
+        attributes['client.address'] = clientAddress;
+    }
+    // User agent
+    if (req.headers['user-agent']) {
+        attributes['user_agent.original'] = req.headers['user-agent'];
+    }
+    return attributes;
+}
+/**
+ * Create and manage HTTP SERVER span for incoming request
+ *
+ * Returns a function to end the span with response status code
+ */
+function createHttpServerSpan(req) {
+    // Extract parent trace context from headers
+    const parentContext = extractTraceContext(req);
+    // Build span name: "{METHOD} {route}"
+    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+    const spanName = `${req.method} ${url.pathname}`;
+    // Get tracer instance (returns no-op if tracing disabled)
+    const tracer = api_1.trace.getTracer('dot-ai-mcp');
+    // Create SERVER span with parent context
+    const span = tracer.startSpan(spanName, {
+        kind: api_1.SpanKind.SERVER,
+        attributes: buildSpanAttributes(req),
+    }, parentContext);
+    // Return span and cleanup function
+    return {
+        span,
+        endSpan: (statusCode) => {
+            // Set response status code
+            span.setAttribute('http.response.status_code', statusCode);
+            // Set span status based on HTTP status code
+            if (statusCode >= 500) {
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: `HTTP ${statusCode}`,
+                });
+            }
+            else {
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+            }
+            span.end();
+        },
+    };
+}
+/**
+ * Wrap HTTP request handler with tracing
+ *
+ * This is a higher-order function that wraps an existing HTTP request handler
+ * with automatic SERVER span creation and management.
+ *
+ * @param handler - Original HTTP request handler
+ * @returns Wrapped handler with tracing
+ */
+function withHttpServerTracing(handler) {
+    return async (req, res) => {
+        const { span, endSpan } = createHttpServerSpan(req);
+        try {
+            // Set span as active context
+            await api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), async () => {
+                await handler(req, res);
+            });
+            // End span with actual response status code
+            endSpan(res.statusCode);
+        }
+        catch (error) {
+            // Record exception and end span with error
+            span.recordException(error);
+            span.setStatus({
+                code: api_1.SpanStatusCode.ERROR,
+                message: error.message,
+            });
+            span.end();
+            throw error;
+        }
+    };
+}

package/dist/core/tracing/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * OpenTelemetry Tracing Module
+ *
+ * Public API for distributed tracing functionality.
+ */
+export * from './types';
+export * from './config';
+export { getTracer, shutdownTracer, withSpan } from './tracer';
+export { createHttpServerSpan, withHttpServerTracing } from './http-tracing';
+export { withToolTracing } from './tool-tracing';
+export { withAITracing } from './ai-tracing';
+export { createTracedK8sClient, withKubectlTracing } from './k8s-tracing';
+export { withQdrantTracing } from './qdrant-tracing';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/tracing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/tracing/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/core/tracing/index.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * OpenTelemetry Tracing Module
+ *
+ * Public API for distributed tracing functionality.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withQdrantTracing = exports.withKubectlTracing = exports.createTracedK8sClient = exports.withAITracing = exports.withToolTracing = exports.withHttpServerTracing = exports.createHttpServerSpan = exports.withSpan = exports.shutdownTracer = exports.getTracer = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./config"), exports);
+var tracer_1 = require("./tracer");
+Object.defineProperty(exports, "getTracer", { enumerable: true, get: function () { return tracer_1.getTracer; } });
+Object.defineProperty(exports, "shutdownTracer", { enumerable: true, get: function () { return tracer_1.shutdownTracer; } });
+Object.defineProperty(exports, "withSpan", { enumerable: true, get: function () { return tracer_1.withSpan; } });
+var http_tracing_1 = require("./http-tracing");
+Object.defineProperty(exports, "createHttpServerSpan", { enumerable: true, get: function () { return http_tracing_1.createHttpServerSpan; } });
+Object.defineProperty(exports, "withHttpServerTracing", { enumerable: true, get: function () { return http_tracing_1.withHttpServerTracing; } });
+var tool_tracing_1 = require("./tool-tracing");
+Object.defineProperty(exports, "withToolTracing", { enumerable: true, get: function () { return tool_tracing_1.withToolTracing; } });
+var ai_tracing_1 = require("./ai-tracing");
+Object.defineProperty(exports, "withAITracing", { enumerable: true, get: function () { return ai_tracing_1.withAITracing; } });
+var k8s_tracing_1 = require("./k8s-tracing");
+Object.defineProperty(exports, "createTracedK8sClient", { enumerable: true, get: function () { return k8s_tracing_1.createTracedK8sClient; } });
+Object.defineProperty(exports, "withKubectlTracing", { enumerable: true, get: function () { return k8s_tracing_1.withKubectlTracing; } });
+var qdrant_tracing_1 = require("./qdrant-tracing");
+Object.defineProperty(exports, "withQdrantTracing", { enumerable: true, get: function () { return qdrant_tracing_1.withQdrantTracing; } });

package/dist/core/tracing/k8s-tracing.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Kubernetes Client Tracing Utilities
+ *
+ * Generic tracing wrappers for Kubernetes operations:
+ * 1. Transparent proxy for @kubernetes/client-node API clients
+ * 2. Wrapper for kubectl CLI command execution
+ *
+ * Uses CLIENT span kind with k8s.* semantic conventions
+ */
+/**
+ * Configuration for kubectl command tracing
+ */
+export interface KubectlConfig {
+    context?: string;
+    namespace?: string;
+    kubeconfig?: string;
+    timeout?: number;
+    stdin?: string;
+}
+/**
+ * Create traced Kubernetes API client using JavaScript Proxy
+ *
+ * Transparently wraps ANY Kubernetes API client method with tracing.
+ * No code changes needed in calling code - just wrap the client once.
+ *
+ * @param apiClient Original K8s API client instance
+ * @param apiType API client type (e.g., 'CoreV1Api', 'AppsV1Api')
+ * @returns Proxied client with automatic tracing for all methods
+ *
+ * @example
+ * const coreApi = createTracedK8sClient(
+ *   kc.makeApiClient(k8s.CoreV1Api),
+ *   'CoreV1Api'
+ * );
+ * await coreApi.listNamespace(); // Automatically traced as "k8s.listNamespace"
+ */
+export declare function createTracedK8sClient<T extends object>(apiClient: T, apiType: string): T;
+/**
+ * Tracing wrapper for kubectl CLI command execution
+ *
+ * Wraps kubectl command execution with OpenTelemetry tracing spans.
+ * Captures command details, operation type, and execution results.
+ *
+ * @param args kubectl command arguments (e.g., ['get', 'pods', '-n', 'default'])
+ * @param config kubectl execution configuration
+ * @param handler Function that executes the actual kubectl command
+ * @returns kubectl command output
+ *
+ * @example
+ * const output = await withKubectlTracing(
+ *   ['get', 'crd', '-o', 'json'],
+ *   { kubeconfig: '/path/to/config' },
+ *   async () => execAsync('kubectl get crd -o json')
+ * );
+ */
+export declare function withKubectlTracing(args: string[], config: KubectlConfig | undefined, handler: () => Promise<string>): Promise<string>;
+//# sourceMappingURL=k8s-tracing.d.ts.map

package/dist/core/tracing/k8s-tracing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-tracing.d.ts","sourceRoot":"","sources":["../../../src/core/tracing/k8s-tracing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,EACpD,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,MAAM,GACd,CAAC,CAoEH;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,aAAa,GAAG,SAAS,EACjC,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAC7B,OAAO,CAAC,MAAM,CAAC,CAgEjB"}