@mastra/otel-exporter 0.0.0-suspendRuntimeContextTypeFix-20250930142630

package/dist/index.js

@@ -0,0 +1,752 @@
+import { AITracingEventType, AISpanType } from '@mastra/core/ai-tracing';
+import { ConsoleLogger } from '@mastra/core/logger';
+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/loadExporter.ts
+var OTLPHttpExporter;
+var OTLPGrpcExporter;
+var OTLPProtoExporter;
+var ZipkinExporter;
+async function loadExporter(protocol, provider) {
+  switch (protocol) {
+    case "zipkin":
+      if (!ZipkinExporter) {
+        try {
+          const module = await import('@opentelemetry/exporter-zipkin');
+          ZipkinExporter = module.ZipkinExporter;
+        } catch {
+          console.error(
+            `[OtelExporter] Zipkin exporter is not installed.
+To use Zipkin export, install the required package:
+  npm install @opentelemetry/exporter-zipkin`
+          );
+          return null;
+        }
+      }
+      return ZipkinExporter;
+    case "grpc":
+      if (!OTLPGrpcExporter) {
+        try {
+          const module = await import('@opentelemetry/exporter-trace-otlp-grpc');
+          OTLPGrpcExporter = module.OTLPTraceExporter;
+        } catch {
+          const providerInfo = provider ? ` (required for ${provider})` : "";
+          console.error(
+            `[OtelExporter] gRPC exporter is not installed${providerInfo}.
+To use gRPC export, install the required packages:
+  npm install @opentelemetry/exporter-trace-otlp-grpc @grpc/grpc-js`
+          );
+          return null;
+        }
+      }
+      return OTLPGrpcExporter;
+    case "http/protobuf":
+      if (!OTLPProtoExporter) {
+        try {
+          const module = await import('@opentelemetry/exporter-trace-otlp-proto');
+          OTLPProtoExporter = module.OTLPTraceExporter;
+        } catch {
+          const providerInfo = provider ? ` (required for ${provider})` : "";
+          console.error(
+            `[OtelExporter] HTTP/Protobuf exporter is not installed${providerInfo}.
+To use HTTP/Protobuf export, install the required package:
+  npm install @opentelemetry/exporter-trace-otlp-proto`
+          );
+          return null;
+        }
+      }
+      return OTLPProtoExporter;
+    case "http/json":
+    default:
+      if (!OTLPHttpExporter) {
+        try {
+          const module = await import('@opentelemetry/exporter-trace-otlp-http');
+          OTLPHttpExporter = module.OTLPTraceExporter;
+        } catch {
+          const providerInfo = provider ? ` (required for ${provider})` : "";
+          console.error(
+            `[OtelExporter] HTTP/JSON exporter is not installed${providerInfo}.
+To use HTTP/JSON export, install the required package:
+  npm install @opentelemetry/exporter-trace-otlp-http`
+          );
+          return null;
+        }
+      }
+      return OTLPHttpExporter;
+  }
+}
+
+// src/provider-configs.ts
+function resolveProviderConfig(config) {
+  if ("dash0" in config) {
+    return resolveDash0Config(config.dash0);
+  } else if ("signoz" in config) {
+    return resolveSignozConfig(config.signoz);
+  } else if ("newrelic" in config) {
+    return resolveNewRelicConfig(config.newrelic);
+  } else if ("traceloop" in config) {
+    return resolveTraceloopConfig(config.traceloop);
+  } else if ("laminar" in config) {
+    return resolveLaminarConfig(config.laminar);
+  } else if ("custom" in config) {
+    return resolveCustomConfig(config.custom);
+  } else {
+    const _exhaustive = config;
+    return _exhaustive;
+  }
+}
+function resolveDash0Config(config) {
+  if (!config.apiKey) {
+    console.error("[OtelExporter] Dash0 configuration requires apiKey. Tracing will be disabled.");
+    return null;
+  }
+  if (!config.endpoint) {
+    console.error("[OtelExporter] Dash0 configuration requires endpoint. Tracing will be disabled.");
+    return null;
+  }
+  let endpoint = config.endpoint;
+  if (!endpoint.includes("/v1/traces")) {
+    endpoint = `${endpoint}/v1/traces`;
+  }
+  const headers = {
+    authorization: `Bearer ${config.apiKey}`
+    // lowercase for gRPC metadata
+  };
+  if (config.dataset) {
+    headers["dash0-dataset"] = config.dataset;
+  }
+  return {
+    endpoint,
+    headers,
+    protocol: "grpc"
+    // Use gRPC for Dash0
+  };
+}
+function resolveSignozConfig(config) {
+  if (!config.apiKey) {
+    console.error("[OtelExporter] SigNoz configuration requires apiKey. Tracing will be disabled.");
+    return null;
+  }
+  const endpoint = config.endpoint || `https://ingest.${config.region || "us"}.signoz.cloud:443/v1/traces`;
+  return {
+    endpoint,
+    headers: {
+      "signoz-ingestion-key": config.apiKey
+    },
+    protocol: "http/protobuf"
+  };
+}
+function resolveNewRelicConfig(config) {
+  if (!config.apiKey) {
+    console.error("[OtelExporter] New Relic configuration requires apiKey (license key). Tracing will be disabled.");
+    return null;
+  }
+  const endpoint = config.endpoint || "https://otlp.nr-data.net:443/v1/traces";
+  return {
+    endpoint,
+    headers: {
+      "api-key": config.apiKey
+    },
+    protocol: "http/protobuf"
+  };
+}
+function resolveTraceloopConfig(config) {
+  if (!config.apiKey) {
+    console.error("[OtelExporter] Traceloop configuration requires apiKey. Tracing will be disabled.");
+    return null;
+  }
+  const endpoint = config.endpoint || "https://api.traceloop.com/v1/traces";
+  const headers = {
+    Authorization: `Bearer ${config.apiKey}`
+  };
+  if (config.destinationId) {
+    headers["x-traceloop-destination-id"] = config.destinationId;
+  }
+  return {
+    endpoint,
+    headers,
+    protocol: "http/json"
+  };
+}
+function resolveLaminarConfig(config) {
+  if (!config.apiKey) {
+    console.error("[OtelExporter] Laminar configuration requires apiKey. Tracing will be disabled.");
+    return null;
+  }
+  const endpoint = config.endpoint || "https://api.lmnr.ai/v1/traces";
+  const headers = {
+    Authorization: `Bearer ${config.apiKey}`
+  };
+  if (config.teamId) {
+    headers["x-laminar-team-id"] = config.teamId;
+  }
+  return {
+    endpoint,
+    headers,
+    protocol: "http/protobuf"
+    // Use HTTP/protobuf instead of gRPC for better compatibility
+  };
+}
+function resolveCustomConfig(config) {
+  if (!config.endpoint) {
+    console.error("[OtelExporter] Custom configuration requires endpoint. Tracing will be disabled.");
+    return null;
+  }
+  return {
+    endpoint: config.endpoint,
+    headers: config.headers || {},
+    protocol: config.protocol || "http/json"
+  };
+}
+var MastraReadableSpan = class {
+  name;
+  kind;
+  spanContext;
+  parentSpanId;
+  startTime;
+  endTime;
+  status;
+  attributes;
+  links;
+  events;
+  duration;
+  ended;
+  resource;
+  instrumentationLibrary;
+  instrumentationScope;
+  droppedAttributesCount = 0;
+  droppedEventsCount = 0;
+  droppedLinksCount = 0;
+  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(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 (aiSpan.errorInfo) {
+      this.status = {
+        code: SpanStatusCode.ERROR,
+        message: aiSpan.errorInfo.message
+      };
+      this.events.push({
+        name: "exception",
+        attributes: {
+          "exception.message": aiSpan.errorInfo.message,
+          "exception.type": "Error",
+          ...aiSpan.errorInfo.details?.stack && {
+            "exception.stacktrace": aiSpan.errorInfo.details.stack
+          }
+        },
+        time: this.startTime,
+        droppedAttributesCount: 0
+      });
+    } else if (aiSpan.endTime) {
+      this.status = { code: SpanStatusCode.OK };
+    } else {
+      this.status = { code: SpanStatusCode.UNSET };
+    }
+    if (aiSpan.isEvent) {
+      this.events.push({
+        name: "instant_event",
+        attributes: {},
+        time: this.startTime,
+        droppedAttributesCount: 0
+      });
+    }
+    this.spanContext = () => ({
+      traceId: aiSpan.traceId,
+      spanId: aiSpan.id,
+      traceFlags: TraceFlags.SAMPLED,
+      isRemote: false
+    });
+    this.resource = resource || {};
+    this.instrumentationLibrary = instrumentationLibrary || {
+      name: "@mastra/otel",
+      version: "1.0.0"
+    };
+    this.instrumentationScope = this.instrumentationLibrary;
+  }
+  /**
+   * Convert JavaScript Date to hrtime format
+   */
+  dateToHrTime(date) {
+    const ms = date.getTime();
+    const seconds = Math.floor(ms / 1e3);
+    const nanoseconds = ms % 1e3 * 1e6;
+    return [seconds, nanoseconds];
+  }
+};
+
+// 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,
+  // Tool calls can be CLIENT (external) or INTERNAL based on context
+  [AISpanType.TOOL_CALL]: SpanKind.INTERNAL,
+  [AISpanType.MCP_TOOL_CALL]: SpanKind.CLIENT,
+  // Root spans for agent/workflow are SERVER (entry points)
+  [AISpanType.AGENT_RUN]: SpanKind.SERVER,
+  [AISpanType.WORKFLOW_RUN]: SpanKind.SERVER,
+  // Internal workflow operations
+  [AISpanType.WORKFLOW_STEP]: SpanKind.INTERNAL,
+  [AISpanType.WORKFLOW_LOOP]: SpanKind.INTERNAL,
+  [AISpanType.WORKFLOW_PARALLEL]: SpanKind.INTERNAL,
+  [AISpanType.WORKFLOW_CONDITIONAL]: SpanKind.INTERNAL,
+  [AISpanType.WORKFLOW_CONDITIONAL_EVAL]: SpanKind.INTERNAL,
+  [AISpanType.WORKFLOW_SLEEP]: SpanKind.INTERNAL,
+  [AISpanType.WORKFLOW_WAIT_EVENT]: SpanKind.INTERNAL,
+  [AISpanType.GENERIC]: SpanKind.INTERNAL
+};
+var SpanConverter = class {
+  resource;
+  instrumentationLibrary;
+  constructor(resource) {
+    this.resource = resource;
+    this.instrumentationLibrary = {
+      name: "@mastra/otel",
+      version: "1.0.0"
+    };
+  }
+  /**
+   * Convert a Mastra AI 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 };
+    return new MastraReadableSpan(
+      otelSpan,
+      attributes,
+      spanKind,
+      aiSpan.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 === AISpanType.AGENT_RUN || aiSpan.type === AISpanType.WORKFLOW_RUN) {
+        return SpanKind.SERVER;
+      }
+    }
+    return SPAN_KIND_MAPPING[aiSpan.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;
+        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;
+        const toolName = toolAttrs?.toolId || "unknown";
+        return `tool.execute ${toolName}`;
+      }
+      case AISpanType.AGENT_RUN: {
+        const agentAttrs = aiSpan.attributes;
+        const agentId = agentAttrs?.agentId || "unknown";
+        return `agent.${agentId}`;
+      }
+      case AISpanType.WORKFLOW_RUN: {
+        const workflowAttrs = aiSpan.attributes;
+        const workflowId = workflowAttrs?.workflowId || "unknown";
+        return `workflow.${workflowId}`;
+      }
+      case AISpanType.WORKFLOW_STEP:
+        return aiSpan.name;
+      default:
+        return aiSpan.name;
+    }
+  }
+  /**
+   * Build OpenTelemetry attributes from Mastra AI span
+   * Following OTEL Semantic Conventions for GenAI
+   */
+  buildAttributes(aiSpan) {
+    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["input"] = inputStr;
+      if (aiSpan.type === AISpanType.LLM_GENERATION) {
+        attributes["gen_ai.prompt"] = inputStr;
+      } else if (aiSpan.type === AISpanType.TOOL_CALL || aiSpan.type === AISpanType.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);
+      attributes["output"] = outputStr;
+      if (aiSpan.type === AISpanType.LLM_GENERATION) {
+        attributes["gen_ai.completion"] = outputStr;
+      } else if (aiSpan.type === AISpanType.TOOL_CALL || aiSpan.type === AISpanType.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 (llmAttrs.provider) {
+        attributes["gen_ai.system"] = llmAttrs.provider;
+      }
+      if (llmAttrs.usage) {
+        const inputTokens = llmAttrs.usage.inputTokens ?? llmAttrs.usage.promptTokens;
+        const outputTokens = llmAttrs.usage.outputTokens ?? llmAttrs.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 (llmAttrs.usage.reasoningTokens !== void 0) {
+          attributes["gen_ai.usage.reasoning_tokens"] = llmAttrs.usage.reasoningTokens;
+        }
+        if (llmAttrs.usage.cachedInputTokens !== void 0) {
+          attributes["gen_ai.usage.cached_input_tokens"] = llmAttrs.usage.cachedInputTokens;
+        }
+      }
+      if (llmAttrs.parameters) {
+        if (llmAttrs.parameters.temperature !== void 0) {
+          attributes["gen_ai.request.temperature"] = llmAttrs.parameters.temperature;
+        }
+        if (llmAttrs.parameters.maxOutputTokens !== void 0) {
+          attributes["gen_ai.request.max_tokens"] = llmAttrs.parameters.maxOutputTokens;
+        }
+        if (llmAttrs.parameters.topP !== void 0) {
+          attributes["gen_ai.request.top_p"] = llmAttrs.parameters.topP;
+        }
+        if (llmAttrs.parameters.topK !== void 0) {
+          attributes["gen_ai.request.top_k"] = llmAttrs.parameters.topK;
+        }
+        if (llmAttrs.parameters.presencePenalty !== void 0) {
+          attributes["gen_ai.request.presence_penalty"] = llmAttrs.parameters.presencePenalty;
+        }
+        if (llmAttrs.parameters.frequencyPenalty !== void 0) {
+          attributes["gen_ai.request.frequency_penalty"] = llmAttrs.parameters.frequencyPenalty;
+        }
+        if (llmAttrs.parameters.stopSequences) {
+          attributes["gen_ai.request.stop_sequences"] = JSON.stringify(llmAttrs.parameters.stopSequences);
+        }
+      }
+      if (llmAttrs.finishReason) {
+        attributes["gen_ai.response.finish_reasons"] = llmAttrs.finishReason;
+      }
+    }
+    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 (aiSpan.type === AISpanType.MCP_TOOL_CALL) {
+        const mcpAttrs = toolAttrs;
+        if (mcpAttrs.mcpServer) {
+          attributes["mcp.server"] = mcpAttrs.mcpServer;
+        }
+        if (mcpAttrs.serverVersion) {
+          attributes["mcp.server.version"] = mcpAttrs.serverVersion;
+        }
+      } else {
+        if (toolAttrs.toolDescription) {
+          attributes["gen_ai.tool.description"] = toolAttrs.toolDescription;
+        }
+      }
+      if (toolAttrs.success !== void 0) {
+        attributes["gen_ai.tool.success"] = toolAttrs.success;
+      }
+    }
+    if (aiSpan.type === AISpanType.AGENT_RUN && aiSpan.attributes) {
+      const agentAttrs = aiSpan.attributes;
+      if (agentAttrs.agentId) {
+        attributes["agent.id"] = agentAttrs.agentId;
+      }
+      if (agentAttrs.maxSteps) {
+        attributes["agent.max_steps"] = agentAttrs.maxSteps;
+      }
+      if (agentAttrs.availableTools) {
+        attributes["agent.available_tools"] = JSON.stringify(agentAttrs.availableTools);
+      }
+    }
+    if (aiSpan.type === AISpanType.WORKFLOW_RUN && aiSpan.attributes) {
+      const workflowAttrs = aiSpan.attributes;
+      if (workflowAttrs.workflowId) {
+        attributes["workflow.id"] = workflowAttrs.workflowId;
+      }
+      if (workflowAttrs.status) {
+        attributes["workflow.status"] = workflowAttrs.status;
+      }
+    }
+    if (aiSpan.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;
+      }
+      if (aiSpan.errorInfo.category) {
+        attributes["error.category"] = aiSpan.errorInfo.category;
+      }
+    }
+    if (aiSpan.metadata) {
+      Object.entries(aiSpan.metadata).forEach(([key, value]) => {
+        if (!attributes[key]) {
+          if (value === null || value === void 0) {
+            return;
+          }
+          if (typeof value === "object") {
+            attributes[key] = JSON.stringify(value);
+          } else {
+            attributes[key] = value;
+          }
+        }
+      });
+    }
+    if (aiSpan.startTime) {
+      attributes["mastra.start_time"] = aiSpan.startTime.toISOString();
+    }
+    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;
+  }
+  /**
+   * 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;
+        return attrs?.resultType === "tool_selection" ? "tool_selection" : "chat";
+      }
+      case AISpanType.TOOL_CALL:
+      case AISpanType.MCP_TOOL_CALL:
+        return "tool.execute";
+      case AISpanType.AGENT_RUN:
+        return "agent.run";
+      case AISpanType.WORKFLOW_RUN:
+        return "workflow.run";
+      default:
+        return aiSpan.type.replace(/_/g, ".");
+    }
+  }
+  /**
+   * Get span kind as string for attribute
+   */
+  getSpanKindString(aiSpan) {
+    const kind = this.getSpanKind(aiSpan);
+    switch (kind) {
+      case SpanKind.SERVER:
+        return "server";
+      case SpanKind.CLIENT:
+        return "client";
+      case SpanKind.INTERNAL:
+        return "internal";
+      case SpanKind.PRODUCER:
+        return "producer";
+      case SpanKind.CONSUMER:
+        return "consumer";
+      default:
+        return "internal";
+    }
+  }
+};
+
+// src/ai-tracing.ts
+var OtelExporter = class {
+  config;
+  tracingConfig;
+  spanConverter;
+  processor;
+  exporter;
+  isSetup = false;
+  isDisabled = false;
+  logger;
+  name = "opentelemetry";
+  constructor(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);
+    }
+  }
+  /**
+   * Initialize with tracing configuration
+   */
+  init(config) {
+    this.tracingConfig = config;
+  }
+  async setupExporter() {
+    if (this.isSetup) return;
+    if (!this.config.provider) {
+      this.logger.error(
+        '[OtelExporter] Provider configuration is required. Use the "custom" provider for generic endpoints.'
+      );
+      this.isDisabled = true;
+      this.isSetup = true;
+      return;
+    }
+    const resolved = resolveProviderConfig(this.config.provider);
+    if (!resolved) {
+      this.isDisabled = true;
+      this.isSetup = true;
+      return;
+    }
+    const endpoint = resolved.endpoint;
+    const headers = resolved.headers;
+    const protocol = resolved.protocol;
+    const providerName = Object.keys(this.config.provider)[0];
+    const ExporterClass = await loadExporter(protocol, providerName);
+    if (!ExporterClass) {
+      this.isDisabled = true;
+      this.isSetup = true;
+      return;
+    }
+    try {
+      if (protocol === "zipkin") {
+        this.exporter = new ExporterClass({
+          url: endpoint,
+          headers
+        });
+      } else if (protocol === "grpc") {
+        let metadata;
+        try {
+          const grpcModule = await import('@grpc/grpc-js');
+          metadata = new grpcModule.Metadata();
+          Object.entries(headers).forEach(([key, value]) => {
+            metadata.set(key, value);
+          });
+        } catch (grpcError) {
+          this.logger.error(
+            `[OtelExporter] Failed to load gRPC metadata. Install required packages:
+  npm install @opentelemetry/exporter-trace-otlp-grpc @grpc/grpc-js
+`,
+            grpcError
+          );
+          this.isDisabled = true;
+          this.isSetup = true;
+          return;
+        }
+        this.exporter = new ExporterClass({
+          url: endpoint,
+          metadata,
+          timeoutMillis: this.config.timeout
+        });
+      } else {
+        this.exporter = new ExporterClass({
+          url: endpoint,
+          headers,
+          timeoutMillis: this.config.timeout
+        });
+      }
+    } catch (error) {
+      this.logger.error(`[OtelExporter] Failed to create exporter:`, error);
+      this.isDisabled = true;
+      this.isSetup = true;
+      return;
+    }
+    const resource = resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: this.tracingConfig?.serviceName || "mastra-service",
+      [ATTR_SERVICE_VERSION]: "1.0.0",
+      // Add telemetry SDK information
+      [ATTR_TELEMETRY_SDK_NAME]: "@mastra/otel-exporter",
+      [ATTR_TELEMETRY_SDK_VERSION]: "1.0.0",
+      [ATTR_TELEMETRY_SDK_LANGUAGE]: "nodejs"
+    });
+    this.spanConverter = new SpanConverter(resource);
+    this.processor = new BatchSpanProcessor(this.exporter, {
+      maxExportBatchSize: this.config.batchSize || 512,
+      // Default batch size
+      maxQueueSize: 2048,
+      // Maximum spans to queue
+      scheduledDelayMillis: 5e3,
+      // Export every 5 seconds
+      exportTimeoutMillis: this.config.timeout || 3e4
+      // Export timeout
+    });
+    this.logger.debug(
+      `[OtelExporter] Using BatchSpanProcessor (batch size: ${this.config.batchSize || 512}, delay: 5s)`
+    );
+    this.isSetup = true;
+  }
+  async exportEvent(event) {
+    if (this.isDisabled) {
+      return;
+    }
+    if (event.type !== AITracingEventType.SPAN_ENDED) {
+      return;
+    }
+    const span = event.exportedSpan;
+    await this.exportSpan(span);
+  }
+  async exportSpan(span) {
+    if (!this.isSetup) {
+      await this.setupExporter();
+    }
+    if (this.isDisabled || !this.processor) {
+      return;
+    }
+    try {
+      const readableSpan = this.spanConverter.convertSpan(span);
+      await new Promise((resolve) => {
+        this.processor.onEnd(readableSpan);
+        resolve();
+      });
+      this.logger.debug(
+        `[OtelExporter] Exported span ${span.id} (trace: ${span.traceId}, parent: ${span.parentSpanId || "none"}, type: ${span.type})`
+      );
+    } catch (error) {
+      this.logger.error(`[OtelExporter] Failed to export span ${span.id}:`, error);
+    }
+  }
+  async shutdown() {
+    if (this.processor) {
+      await this.processor.shutdown();
+    }
+  }
+};
+
+export { OtelExporter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map