@mastra/otel-exporter 0.0.0-extract-tool-ui-inp-playground-ui-20251023135343 → 0.0.0-feat-improve-processors-20251205191721

package/dist/index.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
-var aiTracing = require('@mastra/core/ai-tracing');
-var logger = require('@mastra/core/logger');
+var observability = require('@mastra/core/observability');
+var observability$1 = require('@mastra/observability');
 var api = require('@opentelemetry/api');
 var resources = require('@opentelemetry/resources');
 var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
 
-// src/ai-tracing.ts
+// src/tracing.ts
 
 // src/loadExporter.ts
 var OTLPHttpExporter;
@@ -225,45 +225,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: api.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: api.SpanStatusCode.OK };
     } else {
       this.status = { code: api.SpanStatusCode.UNSET };
     }
-    if (aiSpan.isEvent) {
+    if (span.isEvent) {
       this.events.push({
         name: "instant_event",
         attributes: {},
@@ -272,14 +272,14 @@ var MastraReadableSpan = class {
       });
     }
     this.spanContext = () => ({
-      traceId: aiSpan.traceId,
-      spanId: aiSpan.id,
+      traceId: span.traceId,
+      spanId: span.id,
       traceFlags: api.TraceFlags.SAMPLED,
       isRemote: false
     });
     if (parentSpanId) {
       this.parentSpanContext = {
-        traceId: aiSpan.traceId,
+        traceId: span.traceId,
         spanId: parentSpanId,
         traceFlags: api.TraceFlags.SAMPLED,
         isRemote: false
@@ -306,121 +306,118 @@ var MastraReadableSpan = class {
 // src/span-converter.ts
 var SPAN_KIND_MAPPING = {
   // Model operations are CLIENT spans (calling external AI services)
-  [aiTracing.AISpanType.MODEL_GENERATION]: api.SpanKind.CLIENT,
-  [aiTracing.AISpanType.MODEL_CHUNK]: api.SpanKind.CLIENT,
+  [observability.SpanType.MODEL_GENERATION]: api.SpanKind.CLIENT,
+  [observability.SpanType.MODEL_CHUNK]: api.SpanKind.CLIENT,
   // MCP tool calls are CLIENT (external service calls)
-  [aiTracing.AISpanType.MCP_TOOL_CALL]: api.SpanKind.CLIENT,
+  [observability.SpanType.MCP_TOOL_CALL]: api.SpanKind.CLIENT,
   // Root spans for agent/workflow are SERVER (entry points)
-  [aiTracing.AISpanType.AGENT_RUN]: api.SpanKind.SERVER,
-  [aiTracing.AISpanType.WORKFLOW_RUN]: api.SpanKind.SERVER
+  [observability.SpanType.AGENT_RUN]: api.SpanKind.SERVER,
+  [observability.SpanType.WORKFLOW_RUN]: api.SpanKind.SERVER
 };
+function getSpanKind(type, isRootSpan) {
+  if (isRootSpan) {
+    if (type === observability.SpanType.AGENT_RUN || type === observability.SpanType.WORKFLOW_RUN) {
+      return api.SpanKind.SERVER;
+    }
+  }
+  return SPAN_KIND_MAPPING[type] || api.SpanKind.INTERNAL;
+}
 var SpanConverter = class {
   resource;
   instrumentationLibrary;
   constructor(resource) {
     this.resource = resource;
     this.instrumentationLibrary = {
-      name: "@mastra/otel",
+      name: "@mastra/otel-exporter",
       version: "1.0.0"
     };
   }
   /**
-   * 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 = getSpanKind(span.type, span.isRootSpan);
+    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
     );
   }
-  /**
-   * Get the appropriate SpanKind based on span type and context
-   */
-  getSpanKind(aiSpan) {
-    if (aiSpan.isRootSpan) {
-      if (aiSpan.type === aiTracing.AISpanType.AGENT_RUN || aiSpan.type === aiTracing.AISpanType.WORKFLOW_RUN) {
-        return api.SpanKind.SERVER;
-      }
-    }
-    return SPAN_KIND_MAPPING[aiSpan.type] || api.SpanKind.INTERNAL;
-  }
   /**
    * Build OTEL-compliant span name based on span type and attributes
    */
-  buildSpanName(aiSpan) {
-    switch (aiSpan.type) {
-      case aiTracing.AISpanType.MODEL_GENERATION: {
-        const attrs = aiSpan.attributes;
+  buildSpanName(Span) {
+    switch (Span.type) {
+      case observability.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 aiTracing.AISpanType.TOOL_CALL:
-      case aiTracing.AISpanType.MCP_TOOL_CALL: {
-        const toolAttrs = aiSpan.attributes;
+      case observability.SpanType.TOOL_CALL:
+      case observability.SpanType.MCP_TOOL_CALL: {
+        const toolAttrs = Span.attributes;
         const toolName = toolAttrs?.toolId || "unknown";
         return `tool.execute ${toolName}`;
       }
-      case aiTracing.AISpanType.AGENT_RUN: {
-        const agentAttrs = aiSpan.attributes;
+      case observability.SpanType.AGENT_RUN: {
+        const agentAttrs = Span.attributes;
         const agentId = agentAttrs?.agentId || "unknown";
         return `agent.${agentId}`;
       }
-      case aiTracing.AISpanType.WORKFLOW_RUN: {
-        const workflowAttrs = aiSpan.attributes;
+      case observability.SpanType.WORKFLOW_RUN: {
+        const workflowAttrs = Span.attributes;
         const workflowId = workflowAttrs?.workflowId || "unknown";
         return `workflow.${workflowId}`;
       }
-      case aiTracing.AISpanType.WORKFLOW_STEP:
-        return aiSpan.name;
+      case observability.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;
-    }
-    if (aiSpan.input !== void 0) {
-      const inputStr = typeof aiSpan.input === "string" ? aiSpan.input : JSON.stringify(aiSpan.input);
+    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 (Span.input !== void 0) {
+      const inputStr = typeof Span.input === "string" ? Span.input : JSON.stringify(Span.input);
       attributes["input"] = inputStr;
-      if (aiSpan.type === aiTracing.AISpanType.MODEL_GENERATION) {
+      if (Span.type === observability.SpanType.MODEL_GENERATION) {
         attributes["gen_ai.prompt"] = inputStr;
-      } else if (aiSpan.type === aiTracing.AISpanType.TOOL_CALL || aiSpan.type === aiTracing.AISpanType.MCP_TOOL_CALL) {
+      } else if (Span.type === observability.SpanType.TOOL_CALL || Span.type === observability.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 === aiTracing.AISpanType.MODEL_GENERATION) {
+      if (Span.type === observability.SpanType.MODEL_GENERATION) {
         attributes["gen_ai.completion"] = outputStr;
-      } else if (aiSpan.type === aiTracing.AISpanType.TOOL_CALL || aiSpan.type === aiTracing.AISpanType.MCP_TOOL_CALL) {
+      } else if (Span.type === observability.SpanType.TOOL_CALL || Span.type === observability.SpanType.MCP_TOOL_CALL) {
         attributes["gen_ai.tool.output"] = outputStr;
       }
     }
-    if (aiSpan.type === aiTracing.AISpanType.MODEL_GENERATION && aiSpan.attributes) {
-      const modelAttrs = aiSpan.attributes;
+    if (Span.type === observability.SpanType.MODEL_GENERATION && Span.attributes) {
+      const modelAttrs = Span.attributes;
       if (modelAttrs.model) {
         attributes["gen_ai.request.model"] = modelAttrs.model;
       }
@@ -473,12 +470,12 @@ var SpanConverter = class {
         attributes["gen_ai.response.finish_reasons"] = modelAttrs.finishReason;
       }
     }
-    if ((aiSpan.type === aiTracing.AISpanType.TOOL_CALL || aiSpan.type === aiTracing.AISpanType.MCP_TOOL_CALL) && aiSpan.attributes) {
-      const toolAttrs = aiSpan.attributes;
+    if ((Span.type === observability.SpanType.TOOL_CALL || Span.type === observability.SpanType.MCP_TOOL_CALL) && Span.attributes) {
+      const toolAttrs = Span.attributes;
       if (toolAttrs.toolId) {
         attributes["gen_ai.tool.name"] = toolAttrs.toolId;
       }
-      if (aiSpan.type === aiTracing.AISpanType.MCP_TOOL_CALL) {
+      if (Span.type === observability.SpanType.MCP_TOOL_CALL) {
         const mcpAttrs = toolAttrs;
         if (mcpAttrs.mcpServer) {
           attributes["mcp.server"] = mcpAttrs.mcpServer;
@@ -495,8 +492,8 @@ var SpanConverter = class {
         attributes["gen_ai.tool.success"] = toolAttrs.success;
       }
     }
-    if (aiSpan.type === aiTracing.AISpanType.AGENT_RUN && aiSpan.attributes) {
-      const agentAttrs = aiSpan.attributes;
+    if (Span.type === observability.SpanType.AGENT_RUN && Span.attributes) {
+      const agentAttrs = Span.attributes;
       if (agentAttrs.agentId) {
         attributes["agent.id"] = agentAttrs.agentId;
         attributes["gen_ai.agent.id"] = agentAttrs.agentId;
@@ -508,8 +505,8 @@ var SpanConverter = class {
         attributes["agent.available_tools"] = JSON.stringify(agentAttrs.availableTools);
       }
     }
-    if (aiSpan.type === aiTracing.AISpanType.WORKFLOW_RUN && aiSpan.attributes) {
-      const workflowAttrs = aiSpan.attributes;
+    if (Span.type === observability.SpanType.WORKFLOW_RUN && Span.attributes) {
+      const workflowAttrs = Span.attributes;
       if (workflowAttrs.workflowId) {
         attributes["workflow.id"] = workflowAttrs.workflowId;
       }
@@ -517,19 +514,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;
@@ -542,12 +539,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;
@@ -555,28 +552,28 @@ var SpanConverter = class {
   /**
    * Get the operation name based on span type for gen_ai.operation.name
    */
-  getOperationName(aiSpan) {
-    switch (aiSpan.type) {
-      case aiTracing.AISpanType.MODEL_GENERATION: {
-        const attrs = aiSpan.attributes;
+  getOperationName(Span) {
+    switch (Span.type) {
+      case observability.SpanType.MODEL_GENERATION: {
+        const attrs = Span.attributes;
         return attrs?.resultType === "tool_selection" ? "tool_selection" : "chat";
       }
-      case aiTracing.AISpanType.TOOL_CALL:
-      case aiTracing.AISpanType.MCP_TOOL_CALL:
+      case observability.SpanType.TOOL_CALL:
+      case observability.SpanType.MCP_TOOL_CALL:
         return "tool.execute";
-      case aiTracing.AISpanType.AGENT_RUN:
+      case observability.SpanType.AGENT_RUN:
         return "agent.run";
-      case aiTracing.AISpanType.WORKFLOW_RUN:
+      case observability.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 = getSpanKind(Span.type, Span.isRootSpan);
     switch (kind) {
       case api.SpanKind.SERVER:
         return "server";
@@ -594,21 +591,19 @@ var SpanConverter = class {
   }
 };
 
-// src/ai-tracing.ts
-var OtelExporter = class {
+// src/tracing.ts
+var OtelExporter = class extends observability$1.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 logger.ConsoleLogger({ level: config.logLevel ?? "warn" });
     if (config.logLevel === "debug") {
       api.diag.setLogger(new api.DiagConsoleLogger(), api.DiagLogLevel.DEBUG);
     }
@@ -616,8 +611,8 @@ var OtelExporter = class {
   /**
    * Initialize with tracing configuration
    */
-  init(config) {
-    this.tracingConfig = config;
+  init(options) {
+    this.tracingConfig = options.config;
   }
   async setupExporter() {
     if (this.isSetup || this.exporter) return;
@@ -730,11 +725,8 @@ var OtelExporter = class {
     await this.setupProcessor();
     this.isSetup = true;
   }
-  async exportEvent(event) {
-    if (this.isDisabled) {
-      return;
-    }
-    if (event.type !== aiTracing.AITracingEventType.SPAN_ENDED) {
+  async _exportTracingEvent(event) {
+    if (event.type !== observability.TracingEventType.SPAN_ENDED) {
       return;
     }
     const span = event.exportedSpan;
@@ -767,6 +759,9 @@ var OtelExporter = class {
   }
 };
 
+exports.MastraReadableSpan = MastraReadableSpan;
 exports.OtelExporter = OtelExporter;
+exports.SpanConverter = SpanConverter;
+exports.getSpanKind = getSpanKind;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map