@mastra/otel-exporter 0.0.0-fix-issue-10434-concurrent-write-corruption-20251124213939 → 0.0.0-fix-backport-setserver-20251201151948

package/dist/index.js

@@ -1,11 +1,10 @@
-import { TracingEventType, SpanType } from '@mastra/core/observability';
-import { BaseExporter } from '@mastra/observability';
+import { BaseExporter, AITracingEventType, AISpanType } from '@mastra/core/ai-tracing';
 import { diag, DiagConsoleLogger, DiagLogLevel, SpanKind, SpanStatusCode, TraceFlags } from '@opentelemetry/api';
 import { resourceFromAttributes } from '@opentelemetry/resources';
 import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { ATTR_TELEMETRY_SDK_LANGUAGE, ATTR_TELEMETRY_SDK_VERSION, ATTR_TELEMETRY_SDK_NAME, ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 
-// src/tracing.ts
+// src/ai-tracing.ts
 
 // src/loadExporter.ts
 var OTLPHttpExporter;
@@ -223,45 +222,45 @@ var MastraReadableSpan = class {
   droppedAttributesCount = 0;
   droppedEventsCount = 0;
   droppedLinksCount = 0;
-  constructor(span, attributes, kind, parentSpanId, resource, instrumentationLibrary) {
-    this.name = span.name;
+  constructor(aiSpan, attributes, kind, parentSpanId, resource, instrumentationLibrary) {
+    this.name = aiSpan.name;
     this.kind = kind;
     this.attributes = attributes;
     this.parentSpanId = parentSpanId;
     this.links = [];
     this.events = [];
-    this.startTime = this.dateToHrTime(span.startTime);
-    this.endTime = span.endTime ? this.dateToHrTime(span.endTime) : this.startTime;
-    this.ended = !!span.endTime;
-    if (span.endTime) {
-      const durationMs = span.endTime.getTime() - span.startTime.getTime();
+    this.startTime = this.dateToHrTime(aiSpan.startTime);
+    this.endTime = aiSpan.endTime ? this.dateToHrTime(aiSpan.endTime) : this.startTime;
+    this.ended = !!aiSpan.endTime;
+    if (aiSpan.endTime) {
+      const durationMs = aiSpan.endTime.getTime() - aiSpan.startTime.getTime();
       this.duration = [Math.floor(durationMs / 1e3), durationMs % 1e3 * 1e6];
     } else {
       this.duration = [0, 0];
     }
-    if (span.errorInfo) {
+    if (aiSpan.errorInfo) {
       this.status = {
         code: SpanStatusCode.ERROR,
-        message: span.errorInfo.message
+        message: aiSpan.errorInfo.message
       };
       this.events.push({
         name: "exception",
         attributes: {
-          "exception.message": span.errorInfo.message,
+          "exception.message": aiSpan.errorInfo.message,
           "exception.type": "Error",
-          ...span.errorInfo.details?.stack && {
-            "exception.stacktrace": span.errorInfo.details.stack
+          ...aiSpan.errorInfo.details?.stack && {
+            "exception.stacktrace": aiSpan.errorInfo.details.stack
           }
         },
         time: this.startTime,
         droppedAttributesCount: 0
       });
-    } else if (span.endTime) {
+    } else if (aiSpan.endTime) {
       this.status = { code: SpanStatusCode.OK };
     } else {
       this.status = { code: SpanStatusCode.UNSET };
     }
-    if (span.isEvent) {
+    if (aiSpan.isEvent) {
       this.events.push({
         name: "instant_event",
         attributes: {},
@@ -270,14 +269,14 @@ var MastraReadableSpan = class {
       });
     }
     this.spanContext = () => ({
-      traceId: span.traceId,
-      spanId: span.id,
+      traceId: aiSpan.traceId,
+      spanId: aiSpan.id,
       traceFlags: TraceFlags.SAMPLED,
       isRemote: false
     });
     if (parentSpanId) {
       this.parentSpanContext = {
-        traceId: span.traceId,
+        traceId: aiSpan.traceId,
         spanId: parentSpanId,
         traceFlags: TraceFlags.SAMPLED,
         isRemote: false
@@ -304,13 +303,13 @@ var MastraReadableSpan = class {
 // src/span-converter.ts
 var SPAN_KIND_MAPPING = {
   // Model operations are CLIENT spans (calling external AI services)
-  [SpanType.MODEL_GENERATION]: SpanKind.CLIENT,
-  [SpanType.MODEL_CHUNK]: SpanKind.CLIENT,
+  [AISpanType.MODEL_GENERATION]: SpanKind.CLIENT,
+  [AISpanType.MODEL_CHUNK]: SpanKind.CLIENT,
   // MCP tool calls are CLIENT (external service calls)
-  [SpanType.MCP_TOOL_CALL]: SpanKind.CLIENT,
+  [AISpanType.MCP_TOOL_CALL]: SpanKind.CLIENT,
   // Root spans for agent/workflow are SERVER (entry points)
-  [SpanType.AGENT_RUN]: SpanKind.SERVER,
-  [SpanType.WORKFLOW_RUN]: SpanKind.SERVER
+  [AISpanType.AGENT_RUN]: SpanKind.SERVER,
+  [AISpanType.WORKFLOW_RUN]: SpanKind.SERVER
 };
 var SpanConverter = class {
   resource;
@@ -323,19 +322,19 @@ var SpanConverter = class {
     };
   }
   /**
-   * Convert a Mastra Span to an OpenTelemetry ReadableSpan
+   * Convert a Mastra AI span to an OpenTelemetry ReadableSpan
    * This preserves Mastra's trace and span IDs
    */
-  convertSpan(Span) {
-    const spanKind = this.getSpanKind(Span);
-    const attributes = this.buildAttributes(Span);
-    const spanName = this.buildSpanName(Span);
-    const otelSpan = { ...Span, name: spanName };
+  convertSpan(aiSpan) {
+    const spanKind = this.getSpanKind(aiSpan);
+    const attributes = this.buildAttributes(aiSpan);
+    const spanName = this.buildSpanName(aiSpan);
+    const otelSpan = { ...aiSpan, name: spanName };
     return new MastraReadableSpan(
       otelSpan,
       attributes,
       spanKind,
-      Span.parentSpanId,
+      aiSpan.parentSpanId,
       // Use the parentSpanId from the Mastra span directly
       this.resource,
       this.instrumentationLibrary
@@ -344,81 +343,81 @@ var SpanConverter = class {
   /**
    * Get the appropriate SpanKind based on span type and context
    */
-  getSpanKind(Span) {
-    if (Span.isRootSpan) {
-      if (Span.type === SpanType.AGENT_RUN || Span.type === SpanType.WORKFLOW_RUN) {
+  getSpanKind(aiSpan) {
+    if (aiSpan.isRootSpan) {
+      if (aiSpan.type === AISpanType.AGENT_RUN || aiSpan.type === AISpanType.WORKFLOW_RUN) {
         return SpanKind.SERVER;
       }
     }
-    return SPAN_KIND_MAPPING[Span.type] || SpanKind.INTERNAL;
+    return SPAN_KIND_MAPPING[aiSpan.type] || SpanKind.INTERNAL;
   }
   /**
    * Build OTEL-compliant span name based on span type and attributes
    */
-  buildSpanName(Span) {
-    switch (Span.type) {
-      case SpanType.MODEL_GENERATION: {
-        const attrs = Span.attributes;
+  buildSpanName(aiSpan) {
+    switch (aiSpan.type) {
+      case AISpanType.MODEL_GENERATION: {
+        const attrs = aiSpan.attributes;
         const operation = attrs?.resultType === "tool_selection" ? "tool_selection" : "chat";
         const model = attrs?.model || "unknown";
         return `${operation} ${model}`;
       }
-      case SpanType.TOOL_CALL:
-      case SpanType.MCP_TOOL_CALL: {
-        const toolAttrs = Span.attributes;
+      case AISpanType.TOOL_CALL:
+      case AISpanType.MCP_TOOL_CALL: {
+        const toolAttrs = aiSpan.attributes;
         const toolName = toolAttrs?.toolId || "unknown";
         return `tool.execute ${toolName}`;
       }
-      case SpanType.AGENT_RUN: {
-        const agentAttrs = Span.attributes;
+      case AISpanType.AGENT_RUN: {
+        const agentAttrs = aiSpan.attributes;
         const agentId = agentAttrs?.agentId || "unknown";
         return `agent.${agentId}`;
       }
-      case SpanType.WORKFLOW_RUN: {
-        const workflowAttrs = Span.attributes;
+      case AISpanType.WORKFLOW_RUN: {
+        const workflowAttrs = aiSpan.attributes;
         const workflowId = workflowAttrs?.workflowId || "unknown";
         return `workflow.${workflowId}`;
       }
-      case SpanType.WORKFLOW_STEP:
-        return Span.name;
+      case AISpanType.WORKFLOW_STEP:
+        return aiSpan.name;
       default:
-        return Span.name;
+        return aiSpan.name;
     }
   }
   /**
-   * Build OpenTelemetry attributes from Mastra Span
+   * Build OpenTelemetry attributes from Mastra AI span
    * Following OTEL Semantic Conventions for GenAI
    */
-  buildAttributes(Span) {
+  buildAttributes(aiSpan) {
     const attributes = {};
-    attributes["gen_ai.operation.name"] = this.getOperationName(Span);
-    attributes["span.kind"] = this.getSpanKindString(Span);
-    attributes["mastra.span.type"] = Span.type;
-    attributes["mastra.trace_id"] = Span.traceId;
-    attributes["mastra.span_id"] = Span.id;
-    if (Span.parentSpanId) {
-      attributes["mastra.parent_span_id"] = Span.parentSpanId;
+    attributes["gen_ai.operation.name"] = this.getOperationName(aiSpan);
+    attributes["span.kind"] = this.getSpanKindString(aiSpan);
+    attributes["mastra.span.type"] = aiSpan.type;
+    attributes["mastra.trace_id"] = aiSpan.traceId;
+    attributes["mastra.span_id"] = aiSpan.id;
+    if (aiSpan.parentSpanId) {
+      attributes["mastra.parent_span_id"] = aiSpan.parentSpanId;
     }
-    if (Span.input !== void 0) {
-      const inputStr = typeof Span.input === "string" ? Span.input : JSON.stringify(Span.input);
+    if (aiSpan.input !== void 0) {
+      const inputStr = typeof aiSpan.input === "string" ? aiSpan.input : JSON.stringify(aiSpan.input);
       attributes["input"] = inputStr;
-      if (Span.type === SpanType.MODEL_GENERATION) {
+      if (aiSpan.type === AISpanType.MODEL_GENERATION) {
         attributes["gen_ai.prompt"] = inputStr;
-      } else if (Span.type === SpanType.TOOL_CALL || Span.type === SpanType.MCP_TOOL_CALL) {
+      } else if (aiSpan.type === AISpanType.TOOL_CALL || aiSpan.type === AISpanType.MCP_TOOL_CALL) {
         attributes["gen_ai.tool.input"] = inputStr;
       }
     }
-    if (Span.output !== void 0) {
-      const outputStr = typeof Span.output === "string" ? Span.output : JSON.stringify(Span.output);
+    if (aiSpan.output !== void 0) {
+      const outputStr = typeof aiSpan.output === "string" ? aiSpan.output : JSON.stringify(aiSpan.output);
       attributes["output"] = outputStr;
-      if (Span.type === SpanType.MODEL_GENERATION) {
+      if (aiSpan.type === AISpanType.MODEL_GENERATION) {
         attributes["gen_ai.completion"] = outputStr;
-      } else if (Span.type === SpanType.TOOL_CALL || Span.type === SpanType.MCP_TOOL_CALL) {
+      } else if (aiSpan.type === AISpanType.TOOL_CALL || aiSpan.type === AISpanType.MCP_TOOL_CALL) {
         attributes["gen_ai.tool.output"] = outputStr;
       }
     }
-    if (Span.type === SpanType.MODEL_GENERATION && Span.attributes) {
-      const modelAttrs = Span.attributes;
+    if (aiSpan.type === AISpanType.MODEL_GENERATION && aiSpan.attributes) {
+      const modelAttrs = aiSpan.attributes;
       if (modelAttrs.model) {
         attributes["gen_ai.request.model"] = modelAttrs.model;
       }
@@ -471,12 +470,12 @@ var SpanConverter = class {
         attributes["gen_ai.response.finish_reasons"] = modelAttrs.finishReason;
       }
     }
-    if ((Span.type === SpanType.TOOL_CALL || Span.type === SpanType.MCP_TOOL_CALL) && Span.attributes) {
-      const toolAttrs = Span.attributes;
+    if ((aiSpan.type === AISpanType.TOOL_CALL || aiSpan.type === AISpanType.MCP_TOOL_CALL) && aiSpan.attributes) {
+      const toolAttrs = aiSpan.attributes;
       if (toolAttrs.toolId) {
         attributes["gen_ai.tool.name"] = toolAttrs.toolId;
       }
-      if (Span.type === SpanType.MCP_TOOL_CALL) {
+      if (aiSpan.type === AISpanType.MCP_TOOL_CALL) {
         const mcpAttrs = toolAttrs;
         if (mcpAttrs.mcpServer) {
           attributes["mcp.server"] = mcpAttrs.mcpServer;
@@ -493,8 +492,8 @@ var SpanConverter = class {
         attributes["gen_ai.tool.success"] = toolAttrs.success;
       }
     }
-    if (Span.type === SpanType.AGENT_RUN && Span.attributes) {
-      const agentAttrs = Span.attributes;
+    if (aiSpan.type === AISpanType.AGENT_RUN && aiSpan.attributes) {
+      const agentAttrs = aiSpan.attributes;
       if (agentAttrs.agentId) {
         attributes["agent.id"] = agentAttrs.agentId;
         attributes["gen_ai.agent.id"] = agentAttrs.agentId;
@@ -506,8 +505,8 @@ var SpanConverter = class {
         attributes["agent.available_tools"] = JSON.stringify(agentAttrs.availableTools);
       }
     }
-    if (Span.type === SpanType.WORKFLOW_RUN && Span.attributes) {
-      const workflowAttrs = Span.attributes;
+    if (aiSpan.type === AISpanType.WORKFLOW_RUN && aiSpan.attributes) {
+      const workflowAttrs = aiSpan.attributes;
       if (workflowAttrs.workflowId) {
         attributes["workflow.id"] = workflowAttrs.workflowId;
       }
@@ -515,19 +514,19 @@ var SpanConverter = class {
         attributes["workflow.status"] = workflowAttrs.status;
       }
     }
-    if (Span.errorInfo) {
+    if (aiSpan.errorInfo) {
       attributes["error"] = true;
-      attributes["error.type"] = Span.errorInfo.id || "unknown";
-      attributes["error.message"] = Span.errorInfo.message;
-      if (Span.errorInfo.domain) {
-        attributes["error.domain"] = Span.errorInfo.domain;
+      attributes["error.type"] = aiSpan.errorInfo.id || "unknown";
+      attributes["error.message"] = aiSpan.errorInfo.message;
+      if (aiSpan.errorInfo.domain) {
+        attributes["error.domain"] = aiSpan.errorInfo.domain;
       }
-      if (Span.errorInfo.category) {
-        attributes["error.category"] = Span.errorInfo.category;
+      if (aiSpan.errorInfo.category) {
+        attributes["error.category"] = aiSpan.errorInfo.category;
       }
     }
-    if (Span.metadata) {
-      Object.entries(Span.metadata).forEach(([key, value]) => {
+    if (aiSpan.metadata) {
+      Object.entries(aiSpan.metadata).forEach(([key, value]) => {
         if (!attributes[key]) {
           if (value === null || value === void 0) {
             return;
@@ -540,12 +539,12 @@ var SpanConverter = class {
         }
       });
     }
-    if (Span.startTime) {
-      attributes["mastra.start_time"] = Span.startTime.toISOString();
+    if (aiSpan.startTime) {
+      attributes["mastra.start_time"] = aiSpan.startTime.toISOString();
     }
-    if (Span.endTime) {
-      attributes["mastra.end_time"] = Span.endTime.toISOString();
-      const duration = Span.endTime.getTime() - Span.startTime.getTime();
+    if (aiSpan.endTime) {
+      attributes["mastra.end_time"] = aiSpan.endTime.toISOString();
+      const duration = aiSpan.endTime.getTime() - aiSpan.startTime.getTime();
       attributes["mastra.duration_ms"] = duration;
     }
     return attributes;
@@ -553,28 +552,28 @@ var SpanConverter = class {
   /**
    * Get the operation name based on span type for gen_ai.operation.name
    */
-  getOperationName(Span) {
-    switch (Span.type) {
-      case SpanType.MODEL_GENERATION: {
-        const attrs = Span.attributes;
+  getOperationName(aiSpan) {
+    switch (aiSpan.type) {
+      case AISpanType.MODEL_GENERATION: {
+        const attrs = aiSpan.attributes;
         return attrs?.resultType === "tool_selection" ? "tool_selection" : "chat";
       }
-      case SpanType.TOOL_CALL:
-      case SpanType.MCP_TOOL_CALL:
+      case AISpanType.TOOL_CALL:
+      case AISpanType.MCP_TOOL_CALL:
         return "tool.execute";
-      case SpanType.AGENT_RUN:
+      case AISpanType.AGENT_RUN:
         return "agent.run";
-      case SpanType.WORKFLOW_RUN:
+      case AISpanType.WORKFLOW_RUN:
         return "workflow.run";
       default:
-        return Span.type.replace(/_/g, ".");
+        return aiSpan.type.replace(/_/g, ".");
     }
   }
   /**
    * Get span kind as string for attribute
    */
-  getSpanKindString(Span) {
-    const kind = this.getSpanKind(Span);
+  getSpanKindString(aiSpan) {
+    const kind = this.getSpanKind(aiSpan);
     switch (kind) {
       case SpanKind.SERVER:
         return "server";
@@ -592,7 +591,7 @@ var SpanConverter = class {
   }
 };
 
-// src/tracing.ts
+// src/ai-tracing.ts
 var OtelExporter = class extends BaseExporter {
   config;
   tracingConfig;
@@ -612,8 +611,8 @@ var OtelExporter = class extends BaseExporter {
   /**
    * Initialize with tracing configuration
    */
-  init(options) {
-    this.tracingConfig = options.config;
+  init(config) {
+    this.tracingConfig = config;
   }
   async setupExporter() {
     if (this.isSetup || this.exporter) return;
@@ -726,8 +725,8 @@ var OtelExporter = class extends BaseExporter {
     await this.setupProcessor();
     this.isSetup = true;
   }
-  async _exportTracingEvent(event) {
-    if (event.type !== TracingEventType.SPAN_ENDED) {
+  async _exportEvent(event) {
+    if (event.type !== AITracingEventType.SPAN_ENDED) {
       return;
     }
     const span = event.exportedSpan;