@juspay/neurolink 9.54.6 → 9.54.8

package/dist/lib/workflow/core/workflowRunner.js

@@ -11,8 +11,11 @@
  *
  * @module workflow/core/workflowRunner
  */
+import { SpanStatusCode } from "@opentelemetry/api";
 import { logger } from "../../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../../observability/index.js";
+import { withSpan } from "../../telemetry/withSpan.js";
+import { tracers } from "../../telemetry/tracers.js";
 import { getModelGroups, PLACEHOLDER_MODEL, PLACEHOLDER_PROVIDER, usesModelGroups, } from "../config.js";
 import { validateWorkflow } from "../utils/workflowValidation.js";
 import { executeEnsemble, executeModelGroups } from "./ensembleExecutor.js";
@@ -45,156 +48,172 @@ import { conditionResponse } from "./responseConditioner.js";
  * ```
  */
 export async function runWorkflow(config, options) {
-    const startTime = Date.now();
-    const span = SpanSerializer.createSpan(SpanType.WORKFLOW, "workflow.run", {
-        "workflow.operation": "run",
-        "workflow.name": config.name,
-        "workflow.type": config.type,
-        "workflow.id": config.id,
-    });
-    // Validate configuration
-    const validation = validateWorkflow(config);
-    if (!validation.valid) {
-        span.durationMs = Date.now() - startTime;
-        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, `Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
-        getMetricsAggregator().recordSpan(endedSpan);
-        throw new Error(`Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
-    }
-    if (options.verbose) {
-        logger.debug(`[WorkflowRunner] Starting workflow: ${config.name}`);
-        logger.debug(`[WorkflowRunner] Type: ${config.type}`);
-        logger.debug(`[WorkflowRunner] Uses layer-based execution: ${usesModelGroups(config)}`);
-    }
-    try {
-        // Step 1: Execute models (layer-based or flat)
-        const ensembleResult = await executeModels(config, options);
-        if (options.verbose) {
-            logger.debug(`[WorkflowRunner] Received ${ensembleResult.responses.length} model responses`);
-            logger.debug(`[WorkflowRunner] Successful: ${ensembleResult.successCount}`);
-        }
-        // Step 2: Score responses with judge(s)
-        const scoreResult = await scoreResponses(config, ensembleResult.responses, options);
-        if (options.verbose) {
-            logger.debug(`[WorkflowRunner] Scoring complete`);
-            logger.debug(`[WorkflowRunner] Scores:`, scoreResult.scores);
+    return withSpan({
+        name: "neurolink.workflow.run",
+        tracer: tracers.sdk,
+        attributes: {
+            "workflow.name": config.name,
+            "workflow.type": config.type,
+            "workflow.id": config.id ?? "unknown",
+        },
+    }, async (otelSpan) => {
+        const startTime = Date.now();
+        const span = SpanSerializer.createSpan(SpanType.WORKFLOW, "workflow.run", {
+            "workflow.operation": "run",
+            "workflow.name": config.name,
+            "workflow.type": config.type,
+            "workflow.id": config.id,
+        });
+        // Validate configuration
+        const validation = validateWorkflow(config);
+        if (!validation.valid) {
+            span.durationMs = Date.now() - startTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, `Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
+            getMetricsAggregator().recordSpan(endedSpan);
+            throw new Error(`Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
         }
-        // Step 3: Select best response
-        const bestResponse = selectBestResponse(ensembleResult.responses, scoreResult.scores);
         if (options.verbose) {
-            logger.debug(`[WorkflowRunner] Best response: ${bestResponse.model}`);
-            const bestScore = extractScore(scoreResult.scores, bestResponse, ensembleResult.responses);
-            logger.debug(`[WorkflowRunner] Best score: ${bestScore}`);
-        }
-        // CRITICAL: Store original content BEFORE any processing
-        const originalContent = bestResponse.content;
-        // Step 4: Get processed content
-        // Priority: Judge-synthesized > Separate conditioning > Original
-        let processedContent;
-        let conditioningTime = 0;
-        const judgeScores = isJudgeScores(scoreResult.scores)
-            ? scoreResult.scores
-            : convertToJudgeScores(scoreResult.scores);
-        if (judgeScores.synthesizedResponse) {
-            // Judge already synthesized improved response
-            processedContent = judgeScores.synthesizedResponse;
-            logger.debug(`[WorkflowRunner] Using judge-synthesized response`);
+            logger.debug(`[WorkflowRunner] Starting workflow: ${config.name}`);
+            logger.debug(`[WorkflowRunner] Type: ${config.type}`);
+            logger.debug(`[WorkflowRunner] Uses layer-based execution: ${usesModelGroups(config)}`);
         }
-        else if (config.conditioning) {
-            // Fall back to separate conditioning if configured
-            const conditionedContent = await conditionFinalResponse(bestResponse, scoreResult.scores, config, options, ensembleResult.responses);
-            processedContent = conditionedContent.content;
-            conditioningTime = conditionedContent.conditioningTime;
-            logger.debug(`[WorkflowRunner] Using separate conditioning`);
-        }
-        else {
-            // No processing, use original
-            processedContent = originalContent;
-            logger.debug(`[WorkflowRunner] No conditioning applied`);
-        }
-        // Step 5: Calculate execution metrics
-        const executionTime = Date.now() - startTime;
-        const ensembleTime = ensembleResult.totalTime;
-        const judgeTime = scoreResult.judgeTime;
-        // Step 6: Assemble complete result
-        const result = {
-            // Primary output (processed version)
-            content: processedContent,
-            // IMPORTANT: Store original unmodified response separately
-            originalContent: originalContent,
-            // Evaluation metrics (0-100 scale)
-            score: extractScore(scoreResult.scores, bestResponse, ensembleResult.responses),
-            reasoning: extractReasoning(scoreResult.scores),
-            // Ensemble data
-            ensembleResponses: ensembleResult.responses,
-            // Judge data
-            judgeScores: judgeScores,
-            selectedResponse: bestResponse,
-            // Quality metrics
-            confidence: extractConfidence(scoreResult.scores),
-            consensus: extractConsensus(scoreResult.scores),
-            // Performance metrics
-            totalTime: executionTime,
-            ensembleTime,
-            judgeTime,
-            conditioningTime: conditioningTime,
-            // Workflow metadata
-            workflow: config.id,
-            workflowName: config.name,
-            workflowVersion: config.version,
-            // Resource usage
-            usage: {
-                totalInputTokens: calculateInputTokens(ensembleResult.responses),
-                totalOutputTokens: calculateOutputTokens(ensembleResult.responses),
-                totalTokens: calculateTotalTokens(ensembleResult.responses),
-                byModel: [], // TODO: Populate per-model breakdown
-            },
-            // Additional metadata
-            metadata: options.metadata,
-            timestamp: new Date().toISOString(),
-        };
-        if (options.verbose) {
-            logger.debug(`[WorkflowRunner] Workflow complete in ${executionTime}ms`);
-            logger.debug(`[WorkflowRunner] Total tokens: ${result.usage?.totalTokens || 0}`);
+        try {
+            // Step 1: Execute models (layer-based or flat)
+            const ensembleResult = await executeModels(config, options);
+            if (options.verbose) {
+                logger.debug(`[WorkflowRunner] Received ${ensembleResult.responses.length} model responses`);
+                logger.debug(`[WorkflowRunner] Successful: ${ensembleResult.successCount}`);
+            }
+            // Step 2: Score responses with judge(s)
+            const scoreResult = await scoreResponses(config, ensembleResult.responses, options);
+            if (options.verbose) {
+                logger.debug(`[WorkflowRunner] Scoring complete`);
+                logger.debug(`[WorkflowRunner] Scores:`, scoreResult.scores);
+            }
+            // Step 3: Select best response
+            const bestResponse = selectBestResponse(ensembleResult.responses, scoreResult.scores);
+            if (options.verbose) {
+                logger.debug(`[WorkflowRunner] Best response: ${bestResponse.model}`);
+                const bestScore = extractScore(scoreResult.scores, bestResponse, ensembleResult.responses);
+                logger.debug(`[WorkflowRunner] Best score: ${bestScore}`);
+            }
+            // CRITICAL: Store original content BEFORE any processing
+            const originalContent = bestResponse.content;
+            // Step 4: Get processed content
+            // Priority: Judge-synthesized > Separate conditioning > Original
+            let processedContent;
+            let conditioningTime = 0;
+            const judgeScores = isJudgeScores(scoreResult.scores)
+                ? scoreResult.scores
+                : convertToJudgeScores(scoreResult.scores);
+            if (judgeScores.synthesizedResponse) {
+                // Judge already synthesized improved response
+                processedContent = judgeScores.synthesizedResponse;
+                logger.debug(`[WorkflowRunner] Using judge-synthesized response`);
+            }
+            else if (config.conditioning) {
+                // Fall back to separate conditioning if configured
+                const conditionedContent = await conditionFinalResponse(bestResponse, scoreResult.scores, config, options, ensembleResult.responses);
+                processedContent = conditionedContent.content;
+                conditioningTime = conditionedContent.conditioningTime;
+                logger.debug(`[WorkflowRunner] Using separate conditioning`);
+            }
+            else {
+                // No processing, use original
+                processedContent = originalContent;
+                logger.debug(`[WorkflowRunner] No conditioning applied`);
+            }
+            // Step 5: Calculate execution metrics
+            const executionTime = Date.now() - startTime;
+            const ensembleTime = ensembleResult.totalTime;
+            const judgeTime = scoreResult.judgeTime;
+            // Step 6: Assemble complete result
+            const result = {
+                // Primary output (processed version)
+                content: processedContent,
+                // IMPORTANT: Store original unmodified response separately
+                originalContent: originalContent,
+                // Evaluation metrics (0-100 scale)
+                score: extractScore(scoreResult.scores, bestResponse, ensembleResult.responses),
+                reasoning: extractReasoning(scoreResult.scores),
+                // Ensemble data
+                ensembleResponses: ensembleResult.responses,
+                // Judge data
+                judgeScores: judgeScores,
+                selectedResponse: bestResponse,
+                // Quality metrics
+                confidence: extractConfidence(scoreResult.scores),
+                consensus: extractConsensus(scoreResult.scores),
+                // Performance metrics
+                totalTime: executionTime,
+                ensembleTime,
+                judgeTime,
+                conditioningTime: conditioningTime,
+                // Workflow metadata
+                workflow: config.id,
+                workflowName: config.name,
+                workflowVersion: config.version,
+                // Resource usage
+                usage: {
+                    totalInputTokens: calculateInputTokens(ensembleResult.responses),
+                    totalOutputTokens: calculateOutputTokens(ensembleResult.responses),
+                    totalTokens: calculateTotalTokens(ensembleResult.responses),
+                    byModel: [], // TODO: Populate per-model breakdown
+                },
+                // Additional metadata
+                metadata: options.metadata,
+                timestamp: new Date().toISOString(),
+            };
+            if (options.verbose) {
+                logger.debug(`[WorkflowRunner] Workflow complete in ${executionTime}ms`);
+                logger.debug(`[WorkflowRunner] Total tokens: ${result.usage?.totalTokens || 0}`);
+            }
+            span.durationMs = executionTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+            getMetricsAggregator().recordSpan(endedSpan);
+            return result;
         }
-        span.durationMs = executionTime;
-        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
-        getMetricsAggregator().recordSpan(endedSpan);
-        return result;
-    }
-    catch (error) {
-        const executionTime = Date.now() - startTime;
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        if (options.verbose) {
-            logger.error(`[WorkflowRunner] Workflow failed:`, errorMessage);
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (options.verbose) {
+                logger.error(`[WorkflowRunner] Workflow failed:`, errorMessage);
+            }
+            span.durationMs = executionTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, errorMessage);
+            getMetricsAggregator().recordSpan(endedSpan);
+            // Mark outer OTel span as ERROR since we return instead of rethrowing
+            otelSpan.recordException(error instanceof Error ? error : new Error(errorMessage));
+            otelSpan.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: errorMessage,
+            });
+            // Return error result with dummy data
+            const dummyResponse = {
+                provider: PLACEHOLDER_PROVIDER,
+                model: PLACEHOLDER_MODEL,
+                content: "",
+                responseTime: 0,
+                status: "failure",
+                error: errorMessage,
+                timestamp: new Date().toISOString(),
+            };
+            return {
+                content: "",
+                score: 0,
+                reasoning: `Workflow execution failed: ${errorMessage}`,
+                ensembleResponses: [dummyResponse],
+                confidence: 0,
+                totalTime: executionTime,
+                ensembleTime: 0,
+                workflow: config.id,
+                workflowName: config.name,
+                workflowVersion: config.version,
+                metadata: options.metadata,
+                timestamp: new Date().toISOString(),
+            };
         }
-        span.durationMs = executionTime;
-        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, errorMessage);
-        getMetricsAggregator().recordSpan(endedSpan);
-        // Return error result with dummy data
-        const dummyResponse = {
-            provider: PLACEHOLDER_PROVIDER,
-            model: PLACEHOLDER_MODEL,
-            content: "",
-            responseTime: 0,
-            status: "failure",
-            error: errorMessage,
-            timestamp: new Date().toISOString(),
-        };
-        return {
-            content: "",
-            score: 0,
-            reasoning: `Workflow execution failed: ${errorMessage}`,
-            ensembleResponses: [dummyResponse],
-            confidence: 0,
-            totalTime: executionTime,
-            ensembleTime: 0,
-            workflow: config.id,
-            workflowName: config.name,
-            workflowVersion: config.version,
-            metadata: options.metadata,
-            timestamp: new Date().toISOString(),
-        };
-    }
+    }); // end withSpan
 }
 /**
  * Execute models using layer-based or flat execution
@@ -459,6 +478,18 @@ function calculateTotalTokens(responses) {
  * ```
  */
 export async function* runWorkflowWithStreaming(config, options) {
+    // Wrap the generator in an active OTel span so Pipeline A captures the
+    // streaming workflow end-to-end and Pipeline B (below) inherits its traceId.
+    const generator = tracers.workflow.startActiveSpan("neurolink.workflow.run.streaming", {
+        attributes: {
+            "workflow.name": config.name,
+            "workflow.type": config.type,
+            "workflow.id": config.id ?? "unknown",
+        },
+    }, (otelSpan) => runWorkflowStreamingInner(config, options, otelSpan));
+    yield* generator;
+}
+async function* runWorkflowStreamingInner(config, options, otelSpan) {
     const startTime = Date.now();
     const span = SpanSerializer.createSpan(SpanType.WORKFLOW, "workflow.run.streaming", {
         "workflow.operation": "run.streaming",
@@ -469,14 +500,21 @@ export async function* runWorkflowWithStreaming(config, options) {
     // Validate configuration
     const validation = validateWorkflow(config);
     if (!validation.valid) {
+        const errMsg = `Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`;
         span.durationMs = Date.now() - startTime;
-        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, `Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
+        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, errMsg);
         getMetricsAggregator().recordSpan(endedSpan);
-        throw new Error(`Invalid workflow configuration: ${validation.errors.map((err) => err.message).join(", ")}`);
+        const err = new Error(errMsg);
+        otelSpan.recordException(err);
+        otelSpan.setStatus({ code: SpanStatusCode.ERROR, message: errMsg });
+        otelSpan.end();
+        throw err;
     }
     if (options.verbose) {
         logger.debug(`[WorkflowRunner] Starting streaming workflow: ${config.name}`);
     }
+    // eslint-disable-next-line no-useless-assignment -- read in finally block
+    let spanEnded = false;
     try {
         // Step 1: Execute models
         const ensembleResult = await executeModels(config, options);
@@ -571,17 +609,34 @@ export async function* runWorkflowWithStreaming(config, options) {
         span.durationMs = executionTime;
         const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
         getMetricsAggregator().recordSpan(endedSpan);
+        spanEnded = true;
+        otelSpan.setStatus({ code: SpanStatusCode.OK });
+        otelSpan.end();
     }
     catch (error) {
+        spanEnded = true;
         const executionTime = Date.now() - startTime;
         const errorMessage = error instanceof Error ? error.message : String(error);
         span.durationMs = executionTime;
         const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, errorMessage);
         getMetricsAggregator().recordSpan(endedSpan);
+        if (error instanceof Error) {
+            otelSpan.recordException(error);
+        }
+        otelSpan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+        otelSpan.end();
         logger.error(`[WorkflowRunner] Streaming workflow failed`, {
             error: errorMessage,
         });
         throw error;
     }
+    finally {
+        // Guard against span leak when the consumer breaks out of the async
+        // generator early (neither try-success nor catch fires in that case).
+        if (!spanEnded) {
+            otelSpan.setStatus({ code: SpanStatusCode.OK });
+            otelSpan.end();
+        }
+    }
 }
 //# sourceMappingURL=workflowRunner.js.map

package/dist/mcp/batching/requestBatcher.js

@@ -10,6 +10,8 @@
 import { EventEmitter } from "events";
 import { logger } from "../../utils/logger.js";
 import { ErrorFactory } from "../../utils/errorHandling.js";
+import { withSpan } from "../../telemetry/withSpan.js";
+import { tracers } from "../../telemetry/tracers.js";
 /**
  * Request Batcher - Efficient batch processing for MCP tool calls
  *
@@ -217,85 +219,109 @@ export class RequestBatcher extends EventEmitter {
         const startTime = Date.now();
         this.activeBatches++;
         this.emit("batchStarted", { batchId, size: batchRequests.length });
-        try {
-            // Guard against missing executor
-            if (!this.executor) {
-                throw ErrorFactory.missingConfiguration("batchExecutor", {
-                    hint: "Call setExecutor() before executing batches",
-                });
-            }
-            // Execute the batch with a timeout to prevent indefinite hangs
-            const executorPromise = this.executor(batchRequests.map((r) => ({
-                tool: r.tool,
-                args: r.args,
-                serverId: r.serverId,
-            })));
-            const timeoutMs = Math.max(5000, Number(process.env.MCP_TOOL_TIMEOUT) || 60000);
-            let timeoutHandle;
-            const timeoutPromise = new Promise((_, reject) => {
-                timeoutHandle = setTimeout(() => reject(ErrorFactory.toolTimeout("batchExecution", timeoutMs)), timeoutMs);
-            });
-            const results = await Promise.race([
-                executorPromise,
-                timeoutPromise,
-            ]).finally(() => {
-                if (timeoutHandle) {
-                    clearTimeout(timeoutHandle);
-                }
-            });
-            // Process results
-            const batchResults = [];
-            for (let i = 0; i < batchRequests.length; i++) {
-                const request = batchRequests[i];
-                const result = results[i];
-                const executionTime = Date.now() - startTime;
-                if (!result) {
-                    const noResultError = ErrorFactory.toolExecutionFailed(request.tool, new Error(`Batch executor returned no result for request ${i}`));
-                    request.reject(noResultError);
-                    batchResults.push({
-                        id: request.id,
-                        success: false,
-                        error: noResultError,
-                        executionTime,
+        await withSpan({
+            name: "neurolink.mcp.batch.execute",
+            tracer: tracers.mcp,
+            attributes: {
+                "mcp.batch.id": batchId,
+                "mcp.batch.size": batchRequests.length,
+                "mcp.batch.active_batches": this.activeBatches,
+            },
+        }, async (span) => {
+            let successCount = 0;
+            let errorCount = 0;
+            try {
+                // Guard against missing executor
+                if (!this.executor) {
+                    throw ErrorFactory.missingConfiguration("batchExecutor", {
+                        hint: "Call setExecutor() before executing batches",
                     });
-                    continue;
                 }
-                if (result.success) {
-                    request.resolve(result.result);
-                    batchResults.push({
-                        id: request.id,
-                        success: true,
-                        result: result.result,
-                        executionTime,
-                    });
+                // Execute the batch with a timeout to prevent indefinite hangs
+                const executorPromise = this.executor(batchRequests.map((r) => ({
+                    tool: r.tool,
+                    args: r.args,
+                    serverId: r.serverId,
+                })));
+                const timeoutMs = Math.max(5000, Number(process.env.MCP_TOOL_TIMEOUT) || 60000);
+                let timeoutHandle;
+                const timeoutPromise = new Promise((_, reject) => {
+                    timeoutHandle = setTimeout(() => reject(ErrorFactory.toolTimeout("batchExecution", timeoutMs)), timeoutMs);
+                });
+                // Suppress unhandled rejection if executorPromise rejects after timeout wins
+                void executorPromise.catch((_e) => {
+                    // Intentionally swallowed — timeout already handled the failure
+                });
+                const results = await Promise.race([
+                    executorPromise,
+                    timeoutPromise,
+                ]).finally(() => {
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                });
+                // Process results
+                const batchResults = [];
+                for (let i = 0; i < batchRequests.length; i++) {
+                    const request = batchRequests[i];
+                    const result = results[i];
+                    const executionTime = Date.now() - startTime;
+                    if (!result) {
+                        const noResultError = ErrorFactory.toolExecutionFailed(request.tool, new Error(`Batch executor returned no result for request ${i}`));
+                        request.reject(noResultError);
+                        batchResults.push({
+                            id: request.id,
+                            success: false,
+                            error: noResultError,
+                            executionTime,
+                        });
+                        errorCount++;
+                        continue;
+                    }
+                    if (result.success) {
+                        request.resolve(result.result);
+                        batchResults.push({
+                            id: request.id,
+                            success: true,
+                            result: result.result,
+                            executionTime,
+                        });
+                        successCount++;
+                    }
+                    else {
+                        const error = result.error ??
+                            ErrorFactory.toolExecutionFailed(request.tool, new Error("Unknown batch execution error"));
+                        request.reject(error);
+                        batchResults.push({
+                            id: request.id,
+                            success: false,
+                            error,
+                            executionTime,
+                        });
+                        errorCount++;
+                    }
                 }
-                else {
-                    const error = result.error ??
-                        ErrorFactory.toolExecutionFailed(request.tool, new Error("Unknown batch execution error"));
-                    request.reject(error);
-                    batchResults.push({
-                        id: request.id,
-                        success: false,
-                        error,
-                        executionTime,
-                    });
+                span.setAttribute("mcp.batch.success_count", successCount);
+                span.setAttribute("mcp.batch.error_count", errorCount);
+                this.emit("batchCompleted", { batchId, results: batchResults });
+            }
+            catch (error) {
+                // Batch-level failure - reject all requests
+                const batchError = error instanceof Error
+                    ? error
+                    : ErrorFactory.toolExecutionFailed("batch", new Error(String(error)));
+                for (const request of batchRequests) {
+                    request.reject(batchError);
                 }
+                this.emit("batchFailed", { batchId, error: batchError });
+                throw batchError;
             }
-            this.emit("batchCompleted", { batchId, results: batchResults });
-        }
-        catch (error) {
-            // Batch-level failure - reject all requests
-            const batchError = error instanceof Error
-                ? error
-                : ErrorFactory.toolExecutionFailed("batch", new Error(String(error)));
-            for (const request of batchRequests) {
-                request.reject(batchError);
+            finally {
+                this.activeBatches--;
             }
-            this.emit("batchFailed", { batchId, error: batchError });
-        }
-        finally {
-            this.activeBatches--;
-        }
+        }).catch((error) => {
+            logger.error("Batch span execution failed:", error);
+        });
         // Schedule next batch if there are more pending requests
         if (this.pending.size > 0) {
             this.clearFlushTimer();

package/dist/mcp/httpRateLimiter.js

@@ -5,6 +5,7 @@
  */
 import { mcpLogger } from "../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
+import { getActiveTraceContext } from "../telemetry/traceContext.js";
 /**
  * Default rate limit configuration
  * Provides sensible defaults for most MCP HTTP transport use cases
@@ -72,12 +73,13 @@ export class HTTPRateLimiter {
      * @throws Error if the wait queue is too long
      */
     async acquire() {
+        const { traceId, parentSpanId } = getActiveTraceContext();
         const span = SpanSerializer.createSpan(SpanType.MCP_TRANSPORT, "mcp.rateLimit", {
             "mcp.transport": "http",
             "mcp.operation": "rateLimit",
             "mcp.rateLimit.tokensAvailable": this.tokens,
             "mcp.rateLimit.maxBurst": this.config.maxBurst,
-        });
+        }, parentSpanId, traceId);
         const startTime = Date.now();
         try {
             // First, try to acquire without waiting

package/dist/mcp/httpRetryHandler.js

@@ -8,6 +8,7 @@ import { isAbortError } from "../utils/errorHandling.js";
 import { calculateBackoffDelay } from "../utils/retryHandler.js";
 import { logger } from "../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
+import { getActiveTraceContext } from "../telemetry/traceContext.js";
 /**
  * Default HTTP retry configuration
  */
@@ -130,11 +131,12 @@ export async function withHTTPRetry(operation, config = {}) {
         ...DEFAULT_HTTP_RETRY_CONFIG,
         ...config,
     };
+    const { traceId, parentSpanId } = getActiveTraceContext();
     const span = SpanSerializer.createSpan(SpanType.MCP_TRANSPORT, "mcp.retry", {
         "mcp.transport": "http",
         "mcp.operation": "retry",
         "mcp.maxAttempts": mergedConfig.maxAttempts,
-    });
+    }, parentSpanId, traceId);
     const startTime = Date.now();
     let lastError;
     let actualAttempts = 0;