@mastra/otel-exporter 0.0.0-just-snapshot-20251014192224 → 0.0.0-main-test-05-11-2025-2-20251105214713

package/dist/index.js

@@ -1,11 +1,11 @@
-import { AITracingEventType, AISpanType } from '@mastra/core/ai-tracing';
-import { ConsoleLogger } from '@mastra/core/logger';
+import { TracingEventType, SpanType } from '@mastra/core/observability';
+import { BaseExporter } from '@mastra/observability';
 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/ai-tracing.ts
+// src/tracing.ts
 
 // src/loadExporter.ts
 var OTLPHttpExporter;
@@ -207,6 +207,7 @@ var MastraReadableSpan = class {
   name;
   kind;
   spanContext;
+  parentSpanContext;
   parentSpanId;
   startTime;
   endTime;
@@ -222,45 +223,45 @@ var MastraReadableSpan = class {
   droppedAttributesCount = 0;
   droppedEventsCount = 0;
   droppedLinksCount = 0;
-  constructor(aiSpan, attributes, kind, parentSpanId, resource, instrumentationLibrary) {
-    this.name = aiSpan.name;
+  constructor(span, attributes, kind, parentSpanId, resource, instrumentationLibrary) {
+    this.name = span.name;
     this.kind = kind;
     this.attributes = attributes;
     this.parentSpanId = parentSpanId;
     this.links = [];
     this.events = [];
-    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.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.duration = [Math.floor(durationMs / 1e3), durationMs % 1e3 * 1e6];
     } else {
       this.duration = [0, 0];
     }
-    if (aiSpan.errorInfo) {
+    if (span.errorInfo) {
       this.status = {
         code: SpanStatusCode.ERROR,
-        message: aiSpan.errorInfo.message
+        message: span.errorInfo.message
       };
       this.events.push({
         name: "exception",
         attributes: {
-          "exception.message": aiSpan.errorInfo.message,
+          "exception.message": span.errorInfo.message,
           "exception.type": "Error",
-          ...aiSpan.errorInfo.details?.stack && {
-            "exception.stacktrace": aiSpan.errorInfo.details.stack
+          ...span.errorInfo.details?.stack && {
+            "exception.stacktrace": span.errorInfo.details.stack
           }
         },
         time: this.startTime,
         droppedAttributesCount: 0
       });
-    } else if (aiSpan.endTime) {
+    } else if (span.endTime) {
       this.status = { code: SpanStatusCode.OK };
     } else {
       this.status = { code: SpanStatusCode.UNSET };
     }
-    if (aiSpan.isEvent) {
+    if (span.isEvent) {
       this.events.push({
         name: "instant_event",
         attributes: {},
@@ -269,11 +270,19 @@ var MastraReadableSpan = class {
       });
     }
     this.spanContext = () => ({
-      traceId: aiSpan.traceId,
-      spanId: aiSpan.id,
+      traceId: span.traceId,
+      spanId: span.id,
       traceFlags: TraceFlags.SAMPLED,
       isRemote: false
     });
+    if (parentSpanId) {
+      this.parentSpanContext = {
+        traceId: span.traceId,
+        spanId: parentSpanId,
+        traceFlags: TraceFlags.SAMPLED,
+        isRemote: false
+      };
+    }
     this.resource = resource || {};
     this.instrumentationLibrary = instrumentationLibrary || {
       name: "@mastra/otel",
@@ -294,14 +303,14 @@ var MastraReadableSpan = class {
 
 // src/span-converter.ts
 var SPAN_KIND_MAPPING = {
-  // LLM operations are CLIENT spans (calling external AI services)
-  [AISpanType.LLM_GENERATION]: SpanKind.CLIENT,
-  [AISpanType.LLM_CHUNK]: SpanKind.CLIENT,
+  // Model operations are CLIENT spans (calling external AI services)
+  [SpanType.MODEL_GENERATION]: SpanKind.CLIENT,
+  [SpanType.MODEL_CHUNK]: SpanKind.CLIENT,
   // MCP tool calls are CLIENT (external service calls)
-  [AISpanType.MCP_TOOL_CALL]: SpanKind.CLIENT,
+  [SpanType.MCP_TOOL_CALL]: SpanKind.CLIENT,
   // Root spans for agent/workflow are SERVER (entry points)
-  [AISpanType.AGENT_RUN]: SpanKind.SERVER,
-  [AISpanType.WORKFLOW_RUN]: SpanKind.SERVER
+  [SpanType.AGENT_RUN]: SpanKind.SERVER,
+  [SpanType.WORKFLOW_RUN]: SpanKind.SERVER
 };
 var SpanConverter = class {
   resource;
@@ -314,19 +323,19 @@ var SpanConverter = class {
     };
   }
   /**
-   * Convert a Mastra AI span to an OpenTelemetry ReadableSpan
+   * Convert a Mastra Span to an OpenTelemetry ReadableSpan
    * This preserves Mastra's trace and span IDs
    */
-  convertSpan(aiSpan) {
-    const spanKind = this.getSpanKind(aiSpan);
-    const attributes = this.buildAttributes(aiSpan);
-    const spanName = this.buildSpanName(aiSpan);
-    const otelSpan = { ...aiSpan, name: spanName };
+  convertSpan(Span) {
+    const spanKind = this.getSpanKind(Span);
+    const attributes = this.buildAttributes(Span);
+    const spanName = this.buildSpanName(Span);
+    const otelSpan = { ...Span, name: spanName };
     return new MastraReadableSpan(
       otelSpan,
       attributes,
       spanKind,
-      aiSpan.parentSpanId,
+      Span.parentSpanId,
       // Use the parentSpanId from the Mastra span directly
       this.resource,
       this.instrumentationLibrary
@@ -335,139 +344,139 @@ var SpanConverter = class {
   /**
    * Get the appropriate SpanKind based on span type and context
    */
-  getSpanKind(aiSpan) {
-    if (aiSpan.isRootSpan) {
-      if (aiSpan.type === AISpanType.AGENT_RUN || aiSpan.type === AISpanType.WORKFLOW_RUN) {
+  getSpanKind(Span) {
+    if (Span.isRootSpan) {
+      if (Span.type === SpanType.AGENT_RUN || Span.type === SpanType.WORKFLOW_RUN) {
         return SpanKind.SERVER;
       }
     }
-    return SPAN_KIND_MAPPING[aiSpan.type] || SpanKind.INTERNAL;
+    return SPAN_KIND_MAPPING[Span.type] || SpanKind.INTERNAL;
   }
   /**
    * Build OTEL-compliant span name based on span type and attributes
    */
-  buildSpanName(aiSpan) {
-    switch (aiSpan.type) {
-      case AISpanType.LLM_GENERATION: {
-        const attrs = aiSpan.attributes;
+  buildSpanName(Span) {
+    switch (Span.type) {
+      case SpanType.MODEL_GENERATION: {
+        const attrs = Span.attributes;
         const operation = attrs?.resultType === "tool_selection" ? "tool_selection" : "chat";
         const model = attrs?.model || "unknown";
         return `${operation} ${model}`;
       }
-      case AISpanType.TOOL_CALL:
-      case AISpanType.MCP_TOOL_CALL: {
-        const toolAttrs = aiSpan.attributes;
+      case SpanType.TOOL_CALL:
+      case SpanType.MCP_TOOL_CALL: {
+        const toolAttrs = Span.attributes;
         const toolName = toolAttrs?.toolId || "unknown";
         return `tool.execute ${toolName}`;
       }
-      case AISpanType.AGENT_RUN: {
-        const agentAttrs = aiSpan.attributes;
+      case SpanType.AGENT_RUN: {
+        const agentAttrs = Span.attributes;
         const agentId = agentAttrs?.agentId || "unknown";
         return `agent.${agentId}`;
       }
-      case AISpanType.WORKFLOW_RUN: {
-        const workflowAttrs = aiSpan.attributes;
+      case SpanType.WORKFLOW_RUN: {
+        const workflowAttrs = Span.attributes;
         const workflowId = workflowAttrs?.workflowId || "unknown";
         return `workflow.${workflowId}`;
       }
-      case AISpanType.WORKFLOW_STEP:
-        return aiSpan.name;
+      case SpanType.WORKFLOW_STEP:
+        return Span.name;
       default:
-        return aiSpan.name;
+        return Span.name;
     }
   }
   /**
-   * Build OpenTelemetry attributes from Mastra AI span
+   * Build OpenTelemetry attributes from Mastra Span
    * Following OTEL Semantic Conventions for GenAI
    */
-  buildAttributes(aiSpan) {
+  buildAttributes(Span) {
     const attributes = {};
-    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;
+    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;
     }
-    if (aiSpan.input !== void 0) {
-      const inputStr = typeof aiSpan.input === "string" ? aiSpan.input : JSON.stringify(aiSpan.input);
+    if (Span.input !== void 0) {
+      const inputStr = typeof Span.input === "string" ? Span.input : JSON.stringify(Span.input);
       attributes["input"] = inputStr;
-      if (aiSpan.type === AISpanType.LLM_GENERATION) {
+      if (Span.type === SpanType.MODEL_GENERATION) {
         attributes["gen_ai.prompt"] = inputStr;
-      } else if (aiSpan.type === AISpanType.TOOL_CALL || aiSpan.type === AISpanType.MCP_TOOL_CALL) {
+      } else if (Span.type === SpanType.TOOL_CALL || Span.type === SpanType.MCP_TOOL_CALL) {
         attributes["gen_ai.tool.input"] = inputStr;
       }
     }
-    if (aiSpan.output !== void 0) {
-      const outputStr = typeof aiSpan.output === "string" ? aiSpan.output : JSON.stringify(aiSpan.output);
+    if (Span.output !== void 0) {
+      const outputStr = typeof Span.output === "string" ? Span.output : JSON.stringify(Span.output);
       attributes["output"] = outputStr;
-      if (aiSpan.type === AISpanType.LLM_GENERATION) {
+      if (Span.type === SpanType.MODEL_GENERATION) {
         attributes["gen_ai.completion"] = outputStr;
-      } else if (aiSpan.type === AISpanType.TOOL_CALL || aiSpan.type === AISpanType.MCP_TOOL_CALL) {
+      } else if (Span.type === SpanType.TOOL_CALL || Span.type === SpanType.MCP_TOOL_CALL) {
         attributes["gen_ai.tool.output"] = outputStr;
       }
     }
-    if (aiSpan.type === AISpanType.LLM_GENERATION && aiSpan.attributes) {
-      const llmAttrs = aiSpan.attributes;
-      if (llmAttrs.model) {
-        attributes["gen_ai.request.model"] = llmAttrs.model;
+    if (Span.type === SpanType.MODEL_GENERATION && Span.attributes) {
+      const modelAttrs = Span.attributes;
+      if (modelAttrs.model) {
+        attributes["gen_ai.request.model"] = modelAttrs.model;
       }
-      if (llmAttrs.provider) {
-        attributes["gen_ai.system"] = llmAttrs.provider;
+      if (modelAttrs.provider) {
+        attributes["gen_ai.system"] = modelAttrs.provider;
       }
-      if (llmAttrs.usage) {
-        const inputTokens = llmAttrs.usage.inputTokens ?? llmAttrs.usage.promptTokens;
-        const outputTokens = llmAttrs.usage.outputTokens ?? llmAttrs.usage.completionTokens;
+      if (modelAttrs.usage) {
+        const inputTokens = modelAttrs.usage.inputTokens ?? modelAttrs.usage.promptTokens;
+        const outputTokens = modelAttrs.usage.outputTokens ?? modelAttrs.usage.completionTokens;
         if (inputTokens !== void 0) {
           attributes["gen_ai.usage.input_tokens"] = inputTokens;
         }
         if (outputTokens !== void 0) {
           attributes["gen_ai.usage.output_tokens"] = outputTokens;
         }
-        if (llmAttrs.usage.totalTokens !== void 0) {
-          attributes["gen_ai.usage.total_tokens"] = llmAttrs.usage.totalTokens;
+        if (modelAttrs.usage.totalTokens !== void 0) {
+          attributes["gen_ai.usage.total_tokens"] = modelAttrs.usage.totalTokens;
         }
-        if (llmAttrs.usage.reasoningTokens !== void 0) {
-          attributes["gen_ai.usage.reasoning_tokens"] = llmAttrs.usage.reasoningTokens;
+        if (modelAttrs.usage.reasoningTokens !== void 0) {
+          attributes["gen_ai.usage.reasoning_tokens"] = modelAttrs.usage.reasoningTokens;
         }
-        if (llmAttrs.usage.cachedInputTokens !== void 0) {
-          attributes["gen_ai.usage.cached_input_tokens"] = llmAttrs.usage.cachedInputTokens;
+        if (modelAttrs.usage.cachedInputTokens !== void 0) {
+          attributes["gen_ai.usage.cached_input_tokens"] = modelAttrs.usage.cachedInputTokens;
         }
       }
-      if (llmAttrs.parameters) {
-        if (llmAttrs.parameters.temperature !== void 0) {
-          attributes["gen_ai.request.temperature"] = llmAttrs.parameters.temperature;
+      if (modelAttrs.parameters) {
+        if (modelAttrs.parameters.temperature !== void 0) {
+          attributes["gen_ai.request.temperature"] = modelAttrs.parameters.temperature;
         }
-        if (llmAttrs.parameters.maxOutputTokens !== void 0) {
-          attributes["gen_ai.request.max_tokens"] = llmAttrs.parameters.maxOutputTokens;
+        if (modelAttrs.parameters.maxOutputTokens !== void 0) {
+          attributes["gen_ai.request.max_tokens"] = modelAttrs.parameters.maxOutputTokens;
         }
-        if (llmAttrs.parameters.topP !== void 0) {
-          attributes["gen_ai.request.top_p"] = llmAttrs.parameters.topP;
+        if (modelAttrs.parameters.topP !== void 0) {
+          attributes["gen_ai.request.top_p"] = modelAttrs.parameters.topP;
         }
-        if (llmAttrs.parameters.topK !== void 0) {
-          attributes["gen_ai.request.top_k"] = llmAttrs.parameters.topK;
+        if (modelAttrs.parameters.topK !== void 0) {
+          attributes["gen_ai.request.top_k"] = modelAttrs.parameters.topK;
         }
-        if (llmAttrs.parameters.presencePenalty !== void 0) {
-          attributes["gen_ai.request.presence_penalty"] = llmAttrs.parameters.presencePenalty;
+        if (modelAttrs.parameters.presencePenalty !== void 0) {
+          attributes["gen_ai.request.presence_penalty"] = modelAttrs.parameters.presencePenalty;
         }
-        if (llmAttrs.parameters.frequencyPenalty !== void 0) {
-          attributes["gen_ai.request.frequency_penalty"] = llmAttrs.parameters.frequencyPenalty;
+        if (modelAttrs.parameters.frequencyPenalty !== void 0) {
+          attributes["gen_ai.request.frequency_penalty"] = modelAttrs.parameters.frequencyPenalty;
         }
-        if (llmAttrs.parameters.stopSequences) {
-          attributes["gen_ai.request.stop_sequences"] = JSON.stringify(llmAttrs.parameters.stopSequences);
+        if (modelAttrs.parameters.stopSequences) {
+          attributes["gen_ai.request.stop_sequences"] = JSON.stringify(modelAttrs.parameters.stopSequences);
         }
       }
-      if (llmAttrs.finishReason) {
-        attributes["gen_ai.response.finish_reasons"] = llmAttrs.finishReason;
+      if (modelAttrs.finishReason) {
+        attributes["gen_ai.response.finish_reasons"] = modelAttrs.finishReason;
       }
     }
-    if ((aiSpan.type === AISpanType.TOOL_CALL || aiSpan.type === AISpanType.MCP_TOOL_CALL) && aiSpan.attributes) {
-      const toolAttrs = aiSpan.attributes;
+    if ((Span.type === SpanType.TOOL_CALL || Span.type === SpanType.MCP_TOOL_CALL) && Span.attributes) {
+      const toolAttrs = Span.attributes;
       if (toolAttrs.toolId) {
         attributes["gen_ai.tool.name"] = toolAttrs.toolId;
       }
-      if (aiSpan.type === AISpanType.MCP_TOOL_CALL) {
+      if (Span.type === SpanType.MCP_TOOL_CALL) {
         const mcpAttrs = toolAttrs;
         if (mcpAttrs.mcpServer) {
           attributes["mcp.server"] = mcpAttrs.mcpServer;
@@ -484,10 +493,11 @@ var SpanConverter = class {
         attributes["gen_ai.tool.success"] = toolAttrs.success;
       }
     }
-    if (aiSpan.type === AISpanType.AGENT_RUN && aiSpan.attributes) {
-      const agentAttrs = aiSpan.attributes;
+    if (Span.type === SpanType.AGENT_RUN && Span.attributes) {
+      const agentAttrs = Span.attributes;
       if (agentAttrs.agentId) {
         attributes["agent.id"] = agentAttrs.agentId;
+        attributes["gen_ai.agent.id"] = agentAttrs.agentId;
       }
       if (agentAttrs.maxSteps) {
         attributes["agent.max_steps"] = agentAttrs.maxSteps;
@@ -496,8 +506,8 @@ var SpanConverter = class {
         attributes["agent.available_tools"] = JSON.stringify(agentAttrs.availableTools);
       }
     }
-    if (aiSpan.type === AISpanType.WORKFLOW_RUN && aiSpan.attributes) {
-      const workflowAttrs = aiSpan.attributes;
+    if (Span.type === SpanType.WORKFLOW_RUN && Span.attributes) {
+      const workflowAttrs = Span.attributes;
       if (workflowAttrs.workflowId) {
         attributes["workflow.id"] = workflowAttrs.workflowId;
       }
@@ -505,19 +515,19 @@ var SpanConverter = class {
         attributes["workflow.status"] = workflowAttrs.status;
       }
     }
-    if (aiSpan.errorInfo) {
+    if (Span.errorInfo) {
       attributes["error"] = true;
-      attributes["error.type"] = aiSpan.errorInfo.id || "unknown";
-      attributes["error.message"] = aiSpan.errorInfo.message;
-      if (aiSpan.errorInfo.domain) {
-        attributes["error.domain"] = aiSpan.errorInfo.domain;
+      attributes["error.type"] = Span.errorInfo.id || "unknown";
+      attributes["error.message"] = Span.errorInfo.message;
+      if (Span.errorInfo.domain) {
+        attributes["error.domain"] = Span.errorInfo.domain;
       }
-      if (aiSpan.errorInfo.category) {
-        attributes["error.category"] = aiSpan.errorInfo.category;
+      if (Span.errorInfo.category) {
+        attributes["error.category"] = Span.errorInfo.category;
       }
     }
-    if (aiSpan.metadata) {
-      Object.entries(aiSpan.metadata).forEach(([key, value]) => {
+    if (Span.metadata) {
+      Object.entries(Span.metadata).forEach(([key, value]) => {
         if (!attributes[key]) {
           if (value === null || value === void 0) {
             return;
@@ -530,12 +540,12 @@ var SpanConverter = class {
         }
       });
     }
-    if (aiSpan.startTime) {
-      attributes["mastra.start_time"] = aiSpan.startTime.toISOString();
+    if (Span.startTime) {
+      attributes["mastra.start_time"] = Span.startTime.toISOString();
     }
-    if (aiSpan.endTime) {
-      attributes["mastra.end_time"] = aiSpan.endTime.toISOString();
-      const duration = aiSpan.endTime.getTime() - aiSpan.startTime.getTime();
+    if (Span.endTime) {
+      attributes["mastra.end_time"] = Span.endTime.toISOString();
+      const duration = Span.endTime.getTime() - Span.startTime.getTime();
       attributes["mastra.duration_ms"] = duration;
     }
     return attributes;
@@ -543,28 +553,28 @@ var SpanConverter = class {
   /**
    * Get the operation name based on span type for gen_ai.operation.name
    */
-  getOperationName(aiSpan) {
-    switch (aiSpan.type) {
-      case AISpanType.LLM_GENERATION: {
-        const attrs = aiSpan.attributes;
+  getOperationName(Span) {
+    switch (Span.type) {
+      case SpanType.MODEL_GENERATION: {
+        const attrs = Span.attributes;
         return attrs?.resultType === "tool_selection" ? "tool_selection" : "chat";
       }
-      case AISpanType.TOOL_CALL:
-      case AISpanType.MCP_TOOL_CALL:
+      case SpanType.TOOL_CALL:
+      case SpanType.MCP_TOOL_CALL:
         return "tool.execute";
-      case AISpanType.AGENT_RUN:
+      case SpanType.AGENT_RUN:
         return "agent.run";
-      case AISpanType.WORKFLOW_RUN:
+      case SpanType.WORKFLOW_RUN:
         return "workflow.run";
       default:
-        return aiSpan.type.replace(/_/g, ".");
+        return Span.type.replace(/_/g, ".");
     }
   }
   /**
    * Get span kind as string for attribute
    */
-  getSpanKindString(aiSpan) {
-    const kind = this.getSpanKind(aiSpan);
+  getSpanKindString(Span) {
+    const kind = this.getSpanKind(Span);
     switch (kind) {
       case SpanKind.SERVER:
         return "server";
@@ -582,21 +592,19 @@ var SpanConverter = class {
   }
 };
 
-// src/ai-tracing.ts
-var OtelExporter = class {
+// src/tracing.ts
+var OtelExporter = class extends BaseExporter {
   config;
   tracingConfig;
   spanConverter;
   processor;
   exporter;
   isSetup = false;
-  isDisabled = false;
-  logger;
   name = "opentelemetry";
   constructor(config) {
+    super(config);
     this.config = config;
     this.spanConverter = new SpanConverter();
-    this.logger = new ConsoleLogger({ level: config.logLevel ?? "warn" });
     if (config.logLevel === "debug") {
       diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);
     }
@@ -604,11 +612,11 @@ var OtelExporter = class {
   /**
    * Initialize with tracing configuration
    */
-  init(config) {
-    this.tracingConfig = config;
+  init(options) {
+    this.tracingConfig = options.config;
   }
   async setupExporter() {
-    if (this.isSetup) return;
+    if (this.isSetup || this.exporter) return;
     if (!this.config.provider) {
       this.logger.error(
         '[OtelExporter] Provider configuration is required. Use the "custom" provider for generic endpoints.'
@@ -623,6 +631,10 @@ var OtelExporter = class {
       this.isSetup = true;
       return;
     }
+    if (this.config.exporter) {
+      this.exporter = this.config.exporter;
+      return;
+    }
     const endpoint = resolved.endpoint;
     const headers = resolved.headers;
     const protocol = resolved.protocol;
@@ -676,6 +688,9 @@ var OtelExporter = class {
       this.isSetup = true;
       return;
     }
+  }
+  async setupProcessor() {
+    if (this.processor || this.isSetup) return;
     let resource = resourceFromAttributes({
       [ATTR_SERVICE_NAME]: this.tracingConfig?.serviceName || "mastra-service",
       [ATTR_SERVICE_VERSION]: "1.0.0",
@@ -704,13 +719,15 @@ var OtelExporter = class {
     this.logger.debug(
       `[OtelExporter] Using BatchSpanProcessor (batch size: ${this.config.batchSize || 512}, delay: 5s)`
     );
+  }
+  async setup() {
+    if (this.isSetup) return;
+    await this.setupExporter();
+    await this.setupProcessor();
     this.isSetup = true;
   }
-  async exportEvent(event) {
-    if (this.isDisabled) {
-      return;
-    }
-    if (event.type !== AITracingEventType.SPAN_ENDED) {
+  async _exportTracingEvent(event) {
+    if (event.type !== TracingEventType.SPAN_ENDED) {
       return;
     }
     const span = event.exportedSpan;
@@ -718,7 +735,7 @@ var OtelExporter = class {
   }
   async exportSpan(span) {
     if (!this.isSetup) {
-      await this.setupExporter();
+      await this.setup();
     }
     if (this.isDisabled || !this.processor) {
       return;