@mastra/datadog 1.0.0-beta.2

package/CHANGELOG.md

@@ -0,0 +1,61 @@
+# @mastra/datadog
+
+## 1.0.0-beta.2
+
+### Minor Changes
+
+- Added a Datadog LLM Observability exporter for Mastra applications. ([#11305](https://github.com/mastra-ai/mastra/pull/11305))
+
+  This exporter integrates with Datadog's LLM Observability product to provide comprehensive tracing and monitoring for AI/LLM applications built with Mastra.
+  - **LLM Observability Integration**: Exports traces to Datadog's dedicated LLM Observability product
+  - **Dual Mode Support**: Works with direct HTTPS (agentless) or through a local Datadog Agent
+  - **Span Type Mapping**: Automatically maps Mastra span types to Datadog LLMObs kinds (llm, agent, tool, workflow, task)
+  - **Message Formatting**: LLM inputs/outputs are formatted as message arrays for proper visualization in Datadog
+  - **Token Metrics**: Captures inputTokens, outputTokens, totalTokens, reasoningTokens, and cached tokens
+  - **Error Tracking**: Error spans include detailed error info (message, ID, domain, category)
+  - **Hierarchical Traces**: Tree-based span emission preserves parent-child relationships
+
+  Required settings:
+  - `mlApp`: Groups traces under an ML application name (required)
+  - `apiKey`: Datadog API key (required for agentless mode)
+
+  Optional settings:
+  - `site`: Datadog site (datadoghq.com, datadoghq.eu, us3.datadoghq.com)
+  - `agentless`: true for direct HTTPS (default), false for local agent
+  - `service`, `env`: APM tagging
+  - `integrationsEnabled`: Enable dd-trace auto-instrumentation (default: false)
+
+  ```typescript
+  import { Mastra } from '@mastra/core';
+  import { Observability } from '@mastra/observability';
+  import { DatadogExporter } from '@mastra/datadog';
+
+  const mastra = new Mastra({
+    observability: new Observability({
+      configs: {
+        datadog: {
+          serviceName: 'my-service',
+          exporters: [
+            new DatadogExporter({
+              mlApp: 'my-llm-app',
+              apiKey: process.env.DD_API_KEY,
+            }),
+          ],
+        },
+      },
+    }),
+  });
+  ```
+
+  This is an initial experimental beta release. Breaking changes may occur in future versions as the API evolves.
+
+### Patch Changes
+
+- Updated dependencies [[`08766f1`](https://github.com/mastra-ai/mastra/commit/08766f15e13ac0692fde2a8bd366c2e16e4321df), [`ae8baf7`](https://github.com/mastra-ai/mastra/commit/ae8baf7d8adcb0ff9dac11880400452bc49b33ff), [`cfabdd4`](https://github.com/mastra-ai/mastra/commit/cfabdd4aae7a726b706942d6836eeca110fb6267), [`a0e437f`](https://github.com/mastra-ai/mastra/commit/a0e437fac561b28ee719e0302d72b2f9b4c138f0), [`bec5efd`](https://github.com/mastra-ai/mastra/commit/bec5efde96653ccae6604e68c696d1bc6c1a0bf5), [`9eedf7d`](https://github.com/mastra-ai/mastra/commit/9eedf7de1d6e0022a2f4e5e9e6fe1ec468f9b43c)]:
+  - @mastra/core@1.0.0-beta.21
+
+## 1.0.0-beta.1
+
+### Major Changes
+
+- Initial release of DatadogExporter for Mastra LLM Observability

package/README.md

@@ -0,0 +1,103 @@
+# @mastra/datadog
+
+Datadog LLM Observability exporter for Mastra. Exports observability data to [Datadog's LLM Observability](https://docs.datadoghq.com/llm_observability/) product.
+
+## Installation
+
+```bash
+pnpm add @mastra/datadog
+```
+
+## Requirements
+
+- Datadog account with LLM Observability enabled
+- Datadog API key (available in your Datadog account settings)
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { Mastra } from '@mastra/core';
+import { DatadogExporter } from '@mastra/datadog';
+
+const datadog = new DatadogExporter({
+  mlApp: 'my-llm-app',
+  apiKey: process.env.DD_API_KEY,
+});
+
+const mastra = new Mastra({
+  observability: {
+    configs: {
+      default: {
+        serviceName: 'my-service',
+        exporters: [datadog],
+      },
+    },
+  },
+});
+```
+
+### With Local Datadog Agent (Optional)
+
+If you have a Datadog Agent running locally, you can use agent mode instead:
+
+```typescript
+const datadog = new DatadogExporter({
+  mlApp: 'my-llm-app',
+  agentless: false, // Use local Datadog Agent instead of direct HTTPS
+  env: 'production',
+});
+```
+
+### Configuration Options
+
+| Option                | Description                                          | Default                        |
+| --------------------- | ---------------------------------------------------- | ------------------------------ |
+| `apiKey`              | Datadog API key (required)                           | `DD_API_KEY` env var           |
+| `mlApp`               | ML application name for grouping traces (required)   | `DD_LLMOBS_ML_APP` env var     |
+| `site`                | Datadog site (e.g., 'datadoghq.com', 'datadoghq.eu') | `DD_SITE` or `'datadoghq.com'` |
+| `agentless`           | Use direct HTTPS intake (no local agent required)    | `true`                         |
+| `service`             | Service name for the application                     | Uses `mlApp` value             |
+| `env`                 | Environment name (e.g., 'production', 'staging')     | `DD_ENV` env var               |
+| `integrationsEnabled` | Enable dd-trace automatic integrations               | `false`                        |
+
+Note that the `site` is also used to specify non-default regions, e.g. `us3.datadoghq.com` instead of `us1.datadoghq.com`.
+
+### Environment Variables
+
+The exporter reads configuration from environment variables:
+
+- `DD_API_KEY` - Datadog API key (required)
+- `DD_LLMOBS_ML_APP` - ML application name
+- `DD_SITE` - Datadog site
+- `DD_ENV` - Environment name
+- `DD_LLMOBS_AGENTLESS_ENABLED` - Set to 'false' or '0' to use local Datadog Agent
+
+## Span Type Mapping
+
+Mastra span types are mapped to Datadog LLMObs span kinds:
+
+| Mastra SpanType    | Datadog Kind |
+| ------------------ | ------------ |
+| `AGENT_RUN`        | `agent`      |
+| `MODEL_GENERATION` | `workflow`   |
+| `MODEL_STEP`       | `llm`        |
+| `TOOL_CALL`        | `tool`       |
+| `MCP_TOOL_CALL`    | `tool`       |
+| `WORKFLOW_RUN`     | `workflow`   |
+| All other types    | `task`       |
+
+All unmapped span types (including `MODEL_CHUNK`, `GENERIC`, etc., and future span types) automatically default to `task`.
+
+## Features
+
+- **Completion-only pattern**: Spans are emitted at completion for efficient tracing
+- **Message formatting**: LLM inputs/outputs formatted as message arrays
+- **Metadata as tags**: Span metadata is flattened into searchable Datadog tags
+- **Error tracking**: Error spans include error tags with message, ID, and category
+- **Parent/child hierarchy**: Spans are emitted parent-first to preserve trace trees in Datadog
+
+## License
+
+Apache-2.0

package/dist/index.cjs

@@ -0,0 +1,519 @@
+'use strict';
+
+var observability$1 = require('@mastra/core/observability');
+var utils = require('@mastra/core/utils');
+var observability = require('@mastra/observability');
+var tracer2 = require('dd-trace');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var tracer2__default = /*#__PURE__*/_interopDefault(tracer2);
+
+// src/tracing.ts
+
+// src/metrics.ts
+function formatUsageMetrics(usage) {
+  if (!usage) return void 0;
+  const result = {};
+  const inputTokens = usage.inputTokens;
+  if (inputTokens !== void 0) result.inputTokens = inputTokens;
+  const outputTokens = usage.outputTokens;
+  if (outputTokens !== void 0) result.outputTokens = outputTokens;
+  if (inputTokens !== void 0 && outputTokens !== void 0) {
+    result.totalTokens = inputTokens + outputTokens;
+  }
+  if (usage?.outputDetails?.reasoning !== void 0) {
+    result.reasoningTokens = usage.outputDetails.reasoning;
+  }
+  const cachedTokens = usage?.inputDetails?.cacheRead;
+  if (cachedTokens !== void 0) {
+    result.cachedInputTokens = cachedTokens;
+  }
+  const cachedOutputTokens = usage?.inputDetails?.cacheWrite;
+  if (cachedOutputTokens !== void 0) {
+    result.cachedOutputTokens = cachedOutputTokens;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+var SPAN_TYPE_TO_KIND = {
+  [observability$1.SpanType.AGENT_RUN]: "agent",
+  [observability$1.SpanType.MODEL_GENERATION]: "workflow",
+  [observability$1.SpanType.MODEL_STEP]: "llm",
+  [observability$1.SpanType.TOOL_CALL]: "tool",
+  [observability$1.SpanType.MCP_TOOL_CALL]: "tool",
+  [observability$1.SpanType.WORKFLOW_RUN]: "workflow"
+};
+var tracerInitFlag = { done: false };
+function ensureTracer(config) {
+  if (tracerInitFlag.done) return;
+  if (config.site) {
+    process.env.DD_SITE = config.site;
+  }
+  if (config.apiKey) {
+    process.env.DD_API_KEY = config.apiKey;
+  }
+  const alreadyStarted = tracer2__default.default._tracer?.started;
+  if (!alreadyStarted) {
+    tracer2__default.default.init({
+      service: config.service || config.mlApp,
+      env: config.env || process.env.DD_ENV,
+      // Disable automatic integrations by default to avoid surprise instrumentation
+      plugins: config.integrationsEnabled ?? false
+    });
+  }
+  tracer2__default.default.llmobs.enable({
+    mlApp: config.mlApp,
+    agentlessEnabled: config.agentless
+  });
+  tracerInitFlag.done = true;
+}
+function kindFor(spanType) {
+  return SPAN_TYPE_TO_KIND[spanType] || "task";
+}
+function toDate(value) {
+  return value instanceof Date ? value : new Date(value);
+}
+function safeStringify(data) {
+  try {
+    return JSON.stringify(data);
+  } catch {
+    if (typeof data === "object" && data !== null) {
+      return `[Non-serializable ${data.constructor?.name || "Object"}]`;
+    }
+    return String(data);
+  }
+}
+function isMessageArray(data) {
+  return Array.isArray(data) && data.every((m) => m?.role && m?.content !== void 0);
+}
+function formatInput(input, spanType) {
+  if (spanType === observability$1.SpanType.MODEL_GENERATION || spanType === observability$1.SpanType.MODEL_STEP) {
+    if (isMessageArray(input)) {
+      return input.map((m) => ({
+        role: m.role,
+        content: typeof m.content === "string" ? m.content : safeStringify(m.content)
+      }));
+    }
+    if (typeof input === "string") {
+      return [{ role: "user", content: input }];
+    }
+    return [{ role: "user", content: safeStringify(input) }];
+  }
+  if (typeof input === "string" || Array.isArray(input)) return input;
+  return safeStringify(input);
+}
+function formatOutput(output, spanType) {
+  if (spanType === observability$1.SpanType.MODEL_GENERATION || spanType === observability$1.SpanType.MODEL_STEP) {
+    if (isMessageArray(output)) {
+      return output.map((m) => ({
+        role: m.role,
+        content: typeof m.content === "string" ? m.content : safeStringify(m.content)
+      }));
+    }
+    if (typeof output === "string") {
+      return [{ role: "assistant", content: output }];
+    }
+    if (output?.text) {
+      return [{ role: "assistant", content: output.text }];
+    }
+    return [{ role: "assistant", content: safeStringify(output) }];
+  }
+  if (typeof output === "string") return output;
+  return safeStringify(output);
+}
+
+// src/tracing.ts
+var MAX_TRACE_LIFETIME_MS = 30 * 60 * 1e3;
+var REGULAR_CLEANUP_INTERVAL_MS = 1 * 60 * 1e3;
+var DatadogExporter = class extends observability.BaseExporter {
+  name = "datadog";
+  config;
+  traceContext = /* @__PURE__ */ new Map();
+  traceState = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super(config);
+    const mlApp = config.mlApp || process.env.DD_LLMOBS_ML_APP;
+    const apiKey = config.apiKey || process.env.DD_API_KEY;
+    const site = config.site || process.env.DD_SITE || "datadoghq.com";
+    const envAgentless = process.env.DD_LLMOBS_AGENTLESS_ENABLED?.toLowerCase();
+    const agentless = config.agentless ?? (envAgentless === "false" || envAgentless === "0" ? false : true);
+    if (!mlApp) {
+      this.setDisabled("Missing required mlApp (set config.mlApp or DD_LLMOBS_ML_APP)");
+      this.config = config;
+      return;
+    }
+    if (agentless && !apiKey) {
+      this.setDisabled("Missing required apiKey (set config.apiKey or DD_API_KEY)");
+      this.config = config;
+      return;
+    }
+    this.config = { ...config, mlApp, site, apiKey, agentless };
+    ensureTracer({
+      mlApp,
+      site,
+      apiKey,
+      agentless,
+      service: config.service,
+      env: config.env,
+      integrationsEnabled: config.integrationsEnabled
+    });
+    this.logger.info("Datadog exporter initialized", { mlApp, site, agentless });
+  }
+  /**
+   * Main entry point for tracing events from Mastra.
+   */
+  async _exportTracingEvent(event) {
+    if (this.isDisabled || !tracer2__default.default.llmobs) return;
+    try {
+      const span = event.exportedSpan;
+      if (span.isEvent) {
+        if (event.type === "span_started") {
+          this.captureTraceContext(span);
+          this.enqueueSpan(span);
+        }
+        return;
+      }
+      switch (event.type) {
+        case "span_started":
+          this.captureTraceContext(span);
+          return;
+        case "span_updated":
+          return;
+        case "span_ended":
+          this.enqueueSpan(span);
+          return;
+      }
+    } catch (error) {
+      this.logger.error("Datadog exporter error", {
+        error,
+        eventType: event.type,
+        spanId: event.exportedSpan?.id,
+        spanName: event.exportedSpan?.name
+      });
+    }
+  }
+  /**
+   * Captures user/session context from root spans for tagging all spans in the trace.
+   */
+  captureTraceContext(span) {
+    if (span.isRootSpan && !this.traceContext.has(span.traceId)) {
+      this.traceContext.set(span.traceId, {
+        userId: span.metadata?.userId,
+        sessionId: span.metadata?.sessionId
+      });
+    }
+  }
+  /**
+   * Queue span until its parent context is available, then emit spans parent-first.
+   */
+  enqueueSpan(span) {
+    const state = this.getOrCreateTraceState(span.traceId);
+    if (span.isRootSpan) {
+      state.rootEnded = true;
+    }
+    state.buffer.set(span.id, span);
+    this.tryEmitReadySpans(span.traceId);
+  }
+  /**
+   * Builds annotations object for llmobs.annotate().
+   * Uses dd-trace's expected property names: inputData, outputData, metadata, tags, metrics.
+   */
+  buildAnnotations(span) {
+    const annotations = {};
+    if (span.input !== void 0) {
+      annotations.inputData = formatInput(span.input, span.type);
+    }
+    if (span.output !== void 0) {
+      annotations.outputData = formatOutput(span.output, span.type);
+    }
+    if (span.type === observability$1.SpanType.MODEL_GENERATION || span.type === observability$1.SpanType.MODEL_STEP) {
+      const usage = span.attributes?.usage;
+      const metrics = formatUsageMetrics(usage);
+      if (metrics) {
+        annotations.metrics = metrics;
+      }
+    }
+    const knownFields = ["usage", "model", "provider", "parameters"];
+    const otherAttributes = utils.omitKeys(span.attributes ?? {}, knownFields);
+    const combinedMetadata = {
+      ...span.metadata,
+      ...otherAttributes
+    };
+    if (Object.keys(combinedMetadata).length > 0) {
+      annotations.metadata = combinedMetadata;
+    }
+    const tags = {};
+    if (span.tags?.length) {
+      for (const tag of span.tags) {
+        tags[tag] = true;
+      }
+    }
+    if (span.errorInfo) {
+      tags.error = true;
+      tags.errorInfo = {
+        message: span.errorInfo.message,
+        ...span.errorInfo.id ? { id: span.errorInfo.id } : {},
+        ...span.errorInfo.domain ? { domain: span.errorInfo.domain } : {},
+        ...span.errorInfo.category ? { category: span.errorInfo.category } : {}
+      };
+    }
+    if (Object.keys(tags).length > 0) {
+      annotations.tags = tags;
+    }
+    return annotations;
+  }
+  /**
+   * Gracefully shuts down the exporter.
+   */
+  async shutdown() {
+    for (const [traceId, state] of this.traceState) {
+      if (state.cleanupTimer) {
+        clearTimeout(state.cleanupTimer);
+      }
+      if (state.maxLifetimeTimer) {
+        clearTimeout(state.maxLifetimeTimer);
+      }
+      if (state.buffer.size > 0) {
+        this.logger.warn("Shutdown with pending spans", {
+          traceId,
+          pendingCount: state.buffer.size,
+          spanIds: Array.from(state.buffer.keys())
+        });
+      }
+    }
+    this.traceState.clear();
+    if (tracer2__default.default.llmobs?.flush) {
+      try {
+        await tracer2__default.default.llmobs.flush();
+      } catch (e) {
+        this.logger.error("Error flushing llmobs", { error: e });
+      }
+    } else if (tracer2__default.default.flush) {
+      try {
+        await tracer2__default.default.flush();
+      } catch (e) {
+        this.logger.error("Error flushing tracer", { error: e });
+      }
+    }
+    if (tracer2__default.default.llmobs?.disable) {
+      try {
+        tracer2__default.default.llmobs.disable();
+      } catch (e) {
+        this.logger.error("Error disabling llmobs", { error: e });
+      }
+    }
+    this.traceContext.clear();
+    await super.shutdown();
+  }
+  /**
+   * Retrieve or initialize trace state for buffering and parent tracking.
+   */
+  getOrCreateTraceState(traceId) {
+    const existing = this.traceState.get(traceId);
+    if (existing) {
+      if (existing.cleanupTimer) {
+        clearTimeout(existing.cleanupTimer);
+        existing.cleanupTimer = void 0;
+      }
+      return existing;
+    }
+    const created = {
+      buffer: /* @__PURE__ */ new Map(),
+      contexts: /* @__PURE__ */ new Map(),
+      rootEnded: false,
+      treeEmitted: false,
+      createdAt: Date.now(),
+      cleanupTimer: void 0,
+      maxLifetimeTimer: void 0
+    };
+    const maxLifetimeTimer = setTimeout(() => {
+      const state = this.traceState.get(traceId);
+      if (state) {
+        if (state.buffer.size > 0 || state.contexts.size > 0) {
+          this.logger.warn("Discarding trace due to max lifetime exceeded", {
+            traceId,
+            bufferedSpans: state.buffer.size,
+            emittedSpans: state.contexts.size,
+            lifetimeMs: Date.now() - state.createdAt
+          });
+        }
+        if (state.cleanupTimer) {
+          clearTimeout(state.cleanupTimer);
+        }
+        this.traceState.delete(traceId);
+        this.traceContext.delete(traceId);
+      }
+    }, MAX_TRACE_LIFETIME_MS);
+    maxLifetimeTimer.unref?.();
+    created.maxLifetimeTimer = maxLifetimeTimer;
+    this.traceState.set(traceId, created);
+    return created;
+  }
+  /**
+   * Attempt to emit spans from the buffer.
+   *
+   * Two modes of operation:
+   * 1. Initial tree emission: When root span ends and tree hasn't been emitted yet,
+   *    build a tree from all buffered spans and emit recursively using nested
+   *    llmobs.trace() calls. This ensures proper parent-child relationships in Datadog.
+   * 2. Late-arriving spans: After the tree has been emitted, emit individual spans
+   *    with their parent context for proper linking.
+   */
+  tryEmitReadySpans(traceId) {
+    const state = this.traceState.get(traceId);
+    if (!state) return;
+    if (!state.treeEmitted) {
+      if (!state.rootEnded) return;
+      const tree = this.buildSpanTree(state.buffer);
+      if (tree) {
+        this.emitSpanTree(tree, state);
+      }
+      state.buffer.clear();
+      state.treeEmitted = true;
+    } else {
+      let emitted = false;
+      do {
+        emitted = false;
+        for (const [spanId, span] of state.buffer) {
+          const parentCtx = span.parentSpanId ? state.contexts.get(span.parentSpanId) : void 0;
+          if (span.parentSpanId && !parentCtx) {
+            continue;
+          }
+          this.emitSingleSpan(span, state, parentCtx?.ddSpan);
+          state.buffer.delete(spanId);
+          emitted = true;
+        }
+      } while (emitted);
+    }
+    if (state.rootEnded && state.buffer.size === 0 && !state.cleanupTimer) {
+      const timer = setTimeout(() => {
+        const currentState = this.traceState.get(traceId);
+        if (currentState) {
+          if (currentState.buffer.size > 0) {
+            this.logger.warn("Discarding orphaned spans during cleanup", {
+              traceId,
+              orphanedCount: currentState.buffer.size,
+              spanIds: Array.from(currentState.buffer.keys())
+            });
+          }
+          if (currentState.maxLifetimeTimer) {
+            clearTimeout(currentState.maxLifetimeTimer);
+          }
+        }
+        this.traceState.delete(traceId);
+        this.traceContext.delete(traceId);
+      }, REGULAR_CLEANUP_INTERVAL_MS);
+      timer.unref?.();
+      state.cleanupTimer = timer;
+    }
+  }
+  /**
+   * Builds a tree structure from buffered spans based on parentSpanId relationships.
+   * Returns the root node of the tree, or undefined if no root span is found.
+   */
+  buildSpanTree(buffer) {
+    const nodes = /* @__PURE__ */ new Map();
+    let rootNode;
+    for (const span of buffer.values()) {
+      nodes.set(span.id, { span, children: [] });
+    }
+    for (const node of nodes.values()) {
+      if (node.span.isRootSpan) {
+        rootNode = node;
+      } else if (node.span.parentSpanId) {
+        const parentNode = nodes.get(node.span.parentSpanId);
+        if (parentNode) {
+          parentNode.children.push(node);
+        } else {
+          this.logger.warn("Orphaned span detected during tree build", {
+            spanId: node.span.id,
+            parentSpanId: node.span.parentSpanId,
+            traceId: node.span.traceId
+          });
+        }
+      }
+    }
+    for (const node of nodes.values()) {
+      node.children.sort((a, b) => {
+        const aTime = a.span.startTime instanceof Date ? a.span.startTime.getTime() : new Date(a.span.startTime).getTime();
+        const bTime = b.span.startTime instanceof Date ? b.span.startTime.getTime() : new Date(b.span.startTime).getTime();
+        return aTime - bTime;
+      });
+    }
+    return rootNode;
+  }
+  /**
+   * Builds LLMObs span options from a Mastra span.
+   * Handles trace context, timestamps, and conditional model information for LLM spans.
+   */
+  buildSpanOptions(span) {
+    const traceCtx = this.traceContext.get(span.traceId) || {
+      userId: span.metadata?.userId,
+      sessionId: span.metadata?.sessionId
+    };
+    const kind = kindFor(span.type);
+    const attrs = span.attributes;
+    const startTime = toDate(span.startTime);
+    const endTime = span.endTime ? toDate(span.endTime) : span.isEvent ? startTime : /* @__PURE__ */ new Date();
+    return {
+      kind,
+      name: span.name,
+      sessionId: traceCtx.sessionId,
+      userId: traceCtx.userId,
+      startTime,
+      endTime,
+      ...kind === "llm" && attrs?.model ? { modelName: attrs.model } : {},
+      ...kind === "llm" && attrs?.provider ? { modelProvider: attrs.provider } : {}
+    };
+  }
+  /**
+   * Recursively emits a span tree using nested llmobs.trace() calls.
+   * This ensures parent-child relationships are properly established in Datadog
+   * because child spans are created while their parent span is active in scope.
+   */
+  emitSpanTree(node, state) {
+    const span = node.span;
+    const options = this.buildSpanOptions(span);
+    tracer2__default.default.llmobs.trace(options, (ddSpan) => {
+      const annotations = this.buildAnnotations(span);
+      if (Object.keys(annotations).length > 0) {
+        tracer2__default.default.llmobs.annotate(ddSpan, annotations);
+      }
+      if (span.errorInfo) {
+        ddSpan.setTag("error", true);
+      }
+      const exported = tracer2__default.default.llmobs.exportSpan ? tracer2__default.default.llmobs.exportSpan(ddSpan) : void 0;
+      state.contexts.set(span.id, { ddSpan, exported });
+      for (const child of node.children) {
+        this.emitSpanTree(child, state);
+      }
+    });
+  }
+  /**
+   * Emit a single span with the proper Datadog parent context.
+   * Used for late-arriving spans after the main tree has been emitted.
+   */
+  emitSingleSpan(span, state, parent) {
+    const options = this.buildSpanOptions(span);
+    const runTrace = () => tracer2__default.default.llmobs.trace(options, (ddSpan) => {
+      const annotations = this.buildAnnotations(span);
+      if (Object.keys(annotations).length > 0) {
+        tracer2__default.default.llmobs.annotate(ddSpan, annotations);
+      }
+      if (span.errorInfo) {
+        ddSpan.setTag("error", true);
+      }
+      const exported = tracer2__default.default.llmobs.exportSpan ? tracer2__default.default.llmobs.exportSpan(ddSpan) : void 0;
+      state.contexts.set(span.id, { ddSpan, exported });
+    });
+    if (parent) {
+      tracer2__default.default.scope().activate(parent, runTrace);
+    } else {
+      runTrace();
+    }
+  }
+};
+
+exports.DatadogExporter = DatadogExporter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map