@mastra/datadog 1.1.1-alpha.1 → 1.2.0-alpha.2

package/dist/index.js

@@ -2,8 +2,25 @@ import { SpanType } from '@mastra/core/observability';
 import { omitKeys } from '@mastra/core/utils';
 import { BaseExporter, getExternalParentId } from '@mastra/observability';
 import tracer3 from 'dd-trace';
+import { coreFeatures } from '@mastra/core/features';
 
 // src/bridge.ts
+var FEATURE = "model-inference-span";
+var observabilityFeatures;
+var featureLoadPromise;
+function loadObservabilityFeatures() {
+  if (!featureLoadPromise) {
+    featureLoadPromise = import('@mastra/observability').then((mod) => {
+      observabilityFeatures = mod.observabilityFeatures;
+    }).catch(() => {
+    });
+  }
+  return featureLoadPromise;
+}
+void loadObservabilityFeatures();
+function isModelInferenceEnabled() {
+  return observabilityFeatures?.has(FEATURE) === true && coreFeatures.has(FEATURE);
+}
 
 // src/metrics.ts
 function formatUsageMetrics(usage) {
@@ -29,18 +46,26 @@ function formatUsageMetrics(usage) {
   }
   return Object.keys(result).length > 0 ? result : void 0;
 }
-var SPAN_TYPE_TO_KIND = {
+var SPAN_TYPE_TO_KIND_LEGACY = {
   [SpanType.AGENT_RUN]: "agent",
-  // MODEL_GENERATION is the wrapper around 1..N MODEL_STEPs (the actual API calls).
-  // It maps to 'workflow' so Datadog doesn't double-count it as an LLM call.
   [SpanType.MODEL_GENERATION]: "workflow",
-  // MODEL_STEP is "Single model execution step within a generation (one API call)"
-  // per packages/core/src/observability/types/tracing.ts, so it is the real LLM span.
   [SpanType.MODEL_STEP]: "llm",
   [SpanType.TOOL_CALL]: "tool",
   [SpanType.MCP_TOOL_CALL]: "tool",
   [SpanType.WORKFLOW_RUN]: "workflow"
 };
+var SPAN_TYPE_TO_KIND_INFERENCE = {
+  [SpanType.AGENT_RUN]: "agent",
+  [SpanType.MODEL_GENERATION]: "workflow",
+  [SpanType.MODEL_STEP]: "workflow",
+  [SpanType.MODEL_INFERENCE]: "llm",
+  [SpanType.TOOL_CALL]: "tool",
+  [SpanType.MCP_TOOL_CALL]: "tool",
+  [SpanType.WORKFLOW_RUN]: "workflow"
+};
+function getSpanTypeToKind() {
+  return isModelInferenceEnabled() ? SPAN_TYPE_TO_KIND_INFERENCE : SPAN_TYPE_TO_KIND_LEGACY;
+}
 var tracerInitFlag = { done: false };
 function ensureTracer(config) {
   if (tracerInitFlag.done) return;
@@ -66,7 +91,7 @@ function ensureTracer(config) {
   tracerInitFlag.done = true;
 }
 function kindFor(spanType) {
-  return SPAN_TYPE_TO_KIND[spanType] || "task";
+  return getSpanTypeToKind()[spanType] || "task";
 }
 function toDate(value) {
   return value instanceof Date ? value : new Date(value);
@@ -441,7 +466,8 @@ var DatadogBridge = class extends BaseExporter {
     if (span.output !== void 0) {
       annotations.outputData = formatOutput(span.output, span.type);
     }
-    if (span.type === SpanType.MODEL_STEP) {
+    const usageSpanType = isModelInferenceEnabled() ? SpanType.MODEL_INFERENCE : SpanType.MODEL_STEP;
+    if (span.type === usageSpanType) {
       const usage = span.attributes?.usage;
       const metrics = formatUsageMetrics(usage);
       if (metrics) {
@@ -707,7 +733,8 @@ var DatadogExporter = class extends BaseExporter {
     if (span.output !== void 0) {
       annotations.outputData = formatOutput(span.output, span.type);
     }
-    if (span.type === SpanType.MODEL_STEP) {
+    const usageSpanType = isModelInferenceEnabled() ? SpanType.MODEL_INFERENCE : SpanType.MODEL_STEP;
+    if (span.type === usageSpanType) {
       const usage = span.attributes?.usage;
       const metrics = formatUsageMetrics(usage);
       if (metrics) {
@@ -777,6 +804,63 @@ var DatadogExporter = class extends BaseExporter {
     }
     return annotations;
   }
+  /**
+   * Submit an eval score to Datadog LLM Observability for the matching ddSpan.
+   *
+   * Ordering constraint: the matching span must have already been emitted to dd-trace
+   * (i.e. its `SPAN_ENDED` event must have been processed and the trace tree flushed).
+   * On Mastra's normal scoring path this is always true — scorer hooks fire after the
+   * scored entity completes, so the root span has ended by the time `onScoreEvent` runs.
+   *
+   * If a score arrives for an unexported span (either before `SPAN_ENDED` or after the
+   * `traceState` entry has been cleaned up), the event is dropped and a warning is logged
+   * so the misuse is observable. Scores must therefore only be submitted for spans whose
+   * lifecycle has completed.
+   */
+  async onScoreEvent(event) {
+    if (this.isDisabled || !tracer3.llmobs?.submitEvaluation) return;
+    const { score } = event;
+    if (!score.traceId || !score.spanId) {
+      this.logger.warn("Datadog exporter: dropping score with no traceId/spanId", {
+        scorerId: score.scorerId
+      });
+      return;
+    }
+    const ctx = this.traceState.get(score.traceId)?.contexts.get(score.spanId);
+    const exported = ctx?.exported;
+    if (!exported) {
+      this.logger.warn(
+        "Datadog exporter: dropping score for span that has not been emitted to dd-trace yet (span_ended must be processed before submitting a score for it)",
+        {
+          traceId: score.traceId,
+          spanId: score.spanId,
+          scorerId: score.scorerId
+        }
+      );
+      return;
+    }
+    try {
+      tracer3.llmobs.submitEvaluation(
+        { traceId: exported.traceId, spanId: exported.spanId },
+        {
+          label: score.scorerName ?? score.scorerId,
+          value: score.score,
+          metricType: "score",
+          mlApp: this.config.mlApp,
+          timestampMs: score.timestamp instanceof Date ? score.timestamp.getTime() : Date.now(),
+          ...score.reason ? { reasoning: score.reason } : {},
+          ...score.metadata ? { metadata: score.metadata } : {}
+        }
+      );
+    } catch (err) {
+      this.logger.error("Datadog exporter: Failed to submit evaluation", {
+        error: err,
+        traceId: score.traceId,
+        spanId: score.spanId,
+        scorerId: score.scorerId
+      });
+    }
+  }
   /**
    * Force flush any buffered spans without shutting down the exporter.
    * This is useful in serverless environments where you need to ensure spans