@mastra/observability 0.0.0-span-scorring-test-20251124132129 → 0.0.0-top-level-fix-20251211111608

package/dist/index.cjs

@@ -37,18 +37,38 @@ var observabilityInstanceConfigSchema = zod.z.object({
   serviceName: zod.z.string().min(1, "Service name is required"),
   sampling: samplingStrategySchema.optional(),
   exporters: zod.z.array(zod.z.any()).optional(),
+  bridge: zod.z.any().optional(),
   spanOutputProcessors: zod.z.array(zod.z.any()).optional(),
   includeInternalSpans: zod.z.boolean().optional(),
   requestContextKeys: zod.z.array(zod.z.string()).optional()
-});
+}).refine(
+  (data) => {
+    const hasExporters = data.exporters && data.exporters.length > 0;
+    const hasBridge = !!data.bridge;
+    return hasExporters || hasBridge;
+  },
+  {
+    message: "At least one exporter or a bridge is required"
+  }
+);
 var observabilityConfigValueSchema = zod.z.object({
   serviceName: zod.z.string().min(1, "Service name is required"),
   sampling: samplingStrategySchema.optional(),
   exporters: zod.z.array(zod.z.any()).optional(),
+  bridge: zod.z.any().optional(),
   spanOutputProcessors: zod.z.array(zod.z.any()).optional(),
   includeInternalSpans: zod.z.boolean().optional(),
   requestContextKeys: zod.z.array(zod.z.string()).optional()
-});
+}).refine(
+  (data) => {
+    const hasExporters = data.exporters && data.exporters.length > 0;
+    const hasBridge = !!data.bridge;
+    return hasExporters || hasBridge;
+  },
+  {
+    message: "At least one exporter or a bridge is required"
+  }
+);
 var observabilityRegistryConfigSchema = zod.z.object({
   default: zod.z.object({
     enabled: zod.z.boolean().optional()
@@ -75,6 +95,18 @@ var observabilityRegistryConfigSchema = zod.z.object({
   {
     message: 'A "configSelector" function is required when multiple configs are specified to determine which config to use.'
   }
+).refine(
+  (data) => {
+    if (data.configSelector) {
+      const isDefaultEnabled = data.default?.enabled === true;
+      const hasConfigs = data.configs && typeof data.configs === "object" && !Array.isArray(data.configs) ? Object.keys(data.configs).length > 0 : false;
+      return isDefaultEnabled || hasConfigs;
+    }
+    return true;
+  },
+  {
+    message: 'A "configSelector" requires at least one config or default observability to be configured.'
+  }
 );
 var BaseExporter = class {
   /** Mastra logger instance */
@@ -895,6 +927,79 @@ var DefaultExporter = class extends BaseExporter {
     this.logger.info("DefaultExporter shutdown complete");
   }
 };
+
+// src/exporters/test.ts
+var TestExporter = class extends BaseExporter {
+  name = "tracing-test-exporter";
+  #events = [];
+  constructor(config = {}) {
+    super(config);
+  }
+  async _exportTracingEvent(event) {
+    this.#events.push(event);
+  }
+  clearEvents() {
+    this.#events = [];
+  }
+  get events() {
+    return this.#events;
+  }
+  async shutdown() {
+    this.logger.info("TestExporter shutdown");
+  }
+};
+
+// src/usage.ts
+function extractUsageMetrics(usage, providerMetadata) {
+  if (!usage) {
+    return {};
+  }
+  const inputDetails = {};
+  const outputDetails = {};
+  let inputTokens = usage.inputTokens;
+  const outputTokens = usage.outputTokens;
+  if (usage.cachedInputTokens) {
+    inputDetails.cacheRead = usage.cachedInputTokens;
+  }
+  if (usage.reasoningTokens) {
+    outputDetails.reasoning = usage.reasoningTokens;
+  }
+  const anthropic = providerMetadata?.anthropic;
+  if (anthropic) {
+    if (anthropic.cacheReadInputTokens) {
+      inputDetails.cacheRead = anthropic.cacheReadInputTokens;
+    }
+    if (anthropic.cacheCreationInputTokens) {
+      inputDetails.cacheWrite = anthropic.cacheCreationInputTokens;
+    }
+    if (anthropic.cacheReadInputTokens || anthropic.cacheCreationInputTokens) {
+      inputDetails.text = usage.inputTokens;
+      inputTokens = (usage.inputTokens ?? 0) + (anthropic.cacheReadInputTokens ?? 0) + (anthropic.cacheCreationInputTokens ?? 0);
+    }
+  }
+  const google = providerMetadata?.google;
+  if (google?.usageMetadata) {
+    if (google.usageMetadata.cachedContentTokenCount) {
+      inputDetails.cacheRead = google.usageMetadata.cachedContentTokenCount;
+    }
+    if (google.usageMetadata.thoughtsTokenCount) {
+      outputDetails.reasoning = google.usageMetadata.thoughtsTokenCount;
+    }
+  }
+  const result = {
+    inputTokens,
+    outputTokens
+  };
+  if (Object.keys(inputDetails).length > 0) {
+    result.inputDetails = inputDetails;
+  }
+  if (Object.keys(outputDetails).length > 0) {
+    result.outputDetails = outputDetails;
+  }
+  return result;
+}
+
+// src/model-tracing.ts
 var ModelSpanTracker = class {
   #modelSpan;
   #currentStepSpan;
@@ -902,9 +1007,23 @@ var ModelSpanTracker = class {
   #accumulator = {};
   #stepIndex = 0;
   #chunkSequence = 0;
+  #completionStartTime;
+  /** Tracks tool output accumulators by toolCallId for consolidating sub-agent streams */
+  #toolOutputAccumulators = /* @__PURE__ */ new Map();
+  /** Tracks toolCallIds that had streaming output (to skip redundant tool-result spans) */
+  #streamedToolCallIds = /* @__PURE__ */ new Set();
   constructor(modelSpan) {
     this.#modelSpan = modelSpan;
   }
+  /**
+   * Capture the completion start time (time to first token) when the first content chunk arrives.
+   */
+  #captureCompletionStartTime() {
+    if (this.#completionStartTime) {
+      return;
+    }
+    this.#completionStartTime = /* @__PURE__ */ new Date();
+  }
   /**
    * Get the tracing context for creating child spans.
    * Returns the current step span if active, otherwise the model span.
@@ -921,10 +1040,16 @@ var ModelSpanTracker = class {
     this.#modelSpan?.error(options);
   }
   /**
-   * End the generation span
+   * End the generation span with optional raw usage data.
+   * If usage is provided, it will be converted to UsageStats with cache token details.
    */
   endGeneration(options) {
-    this.#modelSpan?.end(options);
+    const { usage, providerMetadata, ...spanOptions } = options ?? {};
+    if (spanOptions.attributes) {
+      spanOptions.attributes.completionStartTime = this.#completionStartTime;
+      spanOptions.attributes.usage = extractUsageMetrics(usage, providerMetadata);
+    }
+    this.#modelSpan?.end(spanOptions);
   }
   /**
    * Update the generation span
@@ -954,9 +1079,10 @@ var ModelSpanTracker = class {
   #endStepSpan(payload) {
     if (!this.#currentStepSpan) return;
     const output = payload.output;
-    const { usage, ...otherOutput } = output;
+    const { usage: rawUsage, ...otherOutput } = output;
     const stepResult = payload.stepResult;
     const metadata = payload.metadata;
+    const usage = extractUsageMetrics(rawUsage, metadata?.providerMetadata);
     const cleanMetadata = metadata ? { ...metadata } : void 0;
     if (cleanMetadata?.request) {
       delete cleanMetadata.request;
@@ -1129,6 +1255,77 @@ var ModelSpanTracker = class {
         break;
     }
   }
+  /**
+   * Handle tool-output chunks from sub-agents.
+   * Consolidates streaming text/reasoning deltas into a single span per tool call.
+   */
+  #handleToolOutputChunk(chunk) {
+    if (chunk.type !== "tool-output") return;
+    const payload = chunk.payload;
+    const { output, toolCallId, toolName } = payload;
+    let acc = this.#toolOutputAccumulators.get(toolCallId);
+    if (!acc) {
+      if (!this.#currentStepSpan) {
+        this.#startStepSpan();
+      }
+      acc = {
+        toolName: toolName || "unknown",
+        toolCallId,
+        text: "",
+        reasoning: "",
+        sequenceNumber: this.#chunkSequence++,
+        // Name the span 'tool-result' for consistency (tool-call → tool-result)
+        span: this.#currentStepSpan?.createChildSpan({
+          name: `chunk: 'tool-result'`,
+          type: observability.SpanType.MODEL_CHUNK,
+          attributes: {
+            chunkType: "tool-result",
+            sequenceNumber: this.#chunkSequence - 1
+          }
+        })
+      };
+      this.#toolOutputAccumulators.set(toolCallId, acc);
+    }
+    if (output && typeof output === "object" && "type" in output) {
+      const innerType = output.type;
+      switch (innerType) {
+        case "text-delta":
+          if (output.payload?.text) {
+            acc.text += output.payload.text;
+          }
+          break;
+        case "reasoning-delta":
+          if (output.payload?.text) {
+            acc.reasoning += output.payload.text;
+          }
+          break;
+        case "finish":
+        case "workflow-finish":
+          this.#endToolOutputSpan(toolCallId);
+          break;
+      }
+    }
+  }
+  /**
+   * End a tool output span and clean up the accumulator
+   */
+  #endToolOutputSpan(toolCallId) {
+    const acc = this.#toolOutputAccumulators.get(toolCallId);
+    if (!acc) return;
+    const output = {
+      toolCallId: acc.toolCallId,
+      toolName: acc.toolName
+    };
+    if (acc.text) {
+      output.text = acc.text;
+    }
+    if (acc.reasoning) {
+      output.reasoning = acc.reasoning;
+    }
+    acc.span?.end({ output });
+    this.#toolOutputAccumulators.delete(toolCallId);
+    this.#streamedToolCallIds.add(toolCallId);
+  }
   /**
    * Wraps a stream with model tracing transform to track MODEL_STEP and MODEL_CHUNK spans.
    *
@@ -1139,6 +1336,13 @@ var ModelSpanTracker = class {
     return stream.pipeThrough(
       new web.TransformStream({
         transform: (chunk, controller) => {
+          switch (chunk.type) {
+            case "text-delta":
+            case "tool-call-delta":
+            case "reasoning-delta":
+              this.#captureCompletionStartTime();
+              break;
+          }
           controller.enqueue(chunk);
           switch (chunk.type) {
             case "text-start":
@@ -1172,6 +1376,19 @@ var ModelSpanTracker = class {
             case "start":
             case "finish":
               break;
+            case "tool-output":
+              this.#handleToolOutputChunk(chunk);
+              break;
+            case "tool-result": {
+              const toolCallId = chunk.payload?.toolCallId;
+              if (toolCallId && this.#streamedToolCallIds.has(toolCallId)) {
+                this.#streamedToolCallIds.delete(toolCallId);
+                break;
+              }
+              const { args, ...cleanPayload } = chunk.payload || {};
+              this.#createEventSpan(chunk.type, cleanPayload);
+              break;
+            }
             // Default: auto-create event span for all other chunk types
             default: {
               let outputPayload = chunk.payload;
@@ -1226,6 +1443,16 @@ function isSpanInternal(spanType, flags) {
       return false;
   }
 }
+function getExternalParentId(options) {
+  if (!options.parent) {
+    return void 0;
+  }
+  if (options.parent.isInternal) {
+    return options.parent.getParentSpanId(false);
+  } else {
+    return options.parent.id;
+  }
+}
 var BaseSpan = class {
   name;
   type;
@@ -1240,6 +1467,7 @@ var BaseSpan = class {
   output;
   errorInfo;
   metadata;
+  tags;
   traceState;
   /** Parent span ID (for root spans that are children of external spans) */
   parentSpanId;
@@ -1254,6 +1482,7 @@ var BaseSpan = class {
     this.isEvent = options.isEvent ?? false;
     this.isInternal = isSpanInternal(this.type, options.tracingPolicy?.internal);
     this.traceState = options.traceState;
+    this.tags = !options.parent && options.tags?.length ? options.tags : void 0;
     if (this.isEvent) {
       this.output = deepClean(options.output);
     } else {
@@ -1316,12 +1545,36 @@ var BaseSpan = class {
       errorInfo: this.errorInfo,
       isEvent: this.isEvent,
       isRootSpan: this.isRootSpan,
-      parentSpanId: this.getParentSpanId(includeInternalSpans)
+      parentSpanId: this.getParentSpanId(includeInternalSpans),
+      // Tags are only included for root spans
+      ...this.isRootSpan && this.tags?.length ? { tags: this.tags } : {}
     };
   }
   get externalTraceId() {
     return this.isValid ? this.traceId : void 0;
   }
+  /**
+   * Execute an async function within this span's tracing context.
+   * Delegates to the bridge if available.
+   */
+  async executeInContext(fn) {
+    const bridge = this.observabilityInstance.getBridge();
+    if (bridge?.executeInContext) {
+      return bridge.executeInContext(this.id, fn);
+    }
+    return fn();
+  }
+  /**
+   * Execute a synchronous function within this span's tracing context.
+   * Delegates to the bridge if available.
+   */
+  executeInContextSync(fn) {
+    const bridge = this.observabilityInstance.getBridge();
+    if (bridge?.executeInContextSync) {
+      return bridge.executeInContextSync(this.id, fn);
+    }
+    return fn();
+  }
 };
 var DEFAULT_KEYS_TO_STRIP = /* @__PURE__ */ new Set([
   "logger",
@@ -1347,6 +1600,9 @@ function deepClean(value, options = {}, _seen = /* @__PURE__ */ new WeakSet(), _
     return "[Circular]";
   }
   _seen.add(value);
+  if (value instanceof Date) {
+    return value;
+  }
   if (Array.isArray(value)) {
     return value.map((item) => deepClean(item, options, _seen, _depth + 1));
   }
@@ -1368,27 +1624,30 @@ var DefaultSpan = class extends BaseSpan {
   traceId;
   constructor(options, observabilityInstance) {
     super(options, observabilityInstance);
-    this.id = generateSpanId();
+    const bridge = observabilityInstance.getBridge();
+    if (bridge && !this.isInternal) {
+      const bridgeIds = bridge.createSpan(options);
+      if (bridgeIds) {
+        this.id = bridgeIds.spanId;
+        this.traceId = bridgeIds.traceId;
+        this.parentSpanId = bridgeIds.parentSpanId;
+        return;
+      }
+    }
     if (options.parent) {
       this.traceId = options.parent.traceId;
-    } else if (options.traceId) {
-      if (isValidTraceId(options.traceId)) {
-        this.traceId = options.traceId;
-      } else {
-        console.error(
-          `[Mastra Tracing] Invalid traceId: must be 1-32 hexadecimal characters, got "${options.traceId}". Generating new trace ID.`
-        );
-        this.traceId = generateTraceId();
-      }
-    } else {
-      this.traceId = generateTraceId();
+      this.parentSpanId = options.parent.id;
+      this.id = generateSpanId();
+      return;
     }
-    if (!options.parent && options.parentSpanId) {
+    this.traceId = getOrCreateTraceId(options);
+    this.id = generateSpanId();
+    if (options.parentSpanId) {
       if (isValidSpanId(options.parentSpanId)) {
         this.parentSpanId = options.parentSpanId;
       } else {
         console.error(
-          `[Mastra Tracing] Invalid parentSpanId: must be 1-16 hexadecimal characters, got "${options.parentSpanId}". Ignoring parent span ID.`
+          `[Mastra Tracing] Invalid parentSpanId: must be 1-16 hexadecimal characters, got "${options.parentSpanId}". Ignoring.`
         );
       }
     }
@@ -1493,6 +1752,18 @@ function isValidTraceId(traceId) {
 function isValidSpanId(spanId) {
   return /^[0-9a-f]{1,16}$/i.test(spanId);
 }
+function getOrCreateTraceId(options) {
+  if (options.traceId) {
+    if (isValidTraceId(options.traceId)) {
+      return options.traceId;
+    } else {
+      console.error(
+        `[Mastra Tracing] Invalid traceId: must be 1-32 hexadecimal characters, got "${options.traceId}". Generating new trace ID.`
+      );
+    }
+  }
+  return generateTraceId();
+}
 
 // src/spans/no-op.ts
 var NoOpSpan = class extends BaseSpan {
@@ -1525,13 +1796,17 @@ var BaseObservabilityInstance = class extends base.MastraBase {
       sampling: config.sampling ?? { type: "always" /* ALWAYS */ },
       exporters: config.exporters ?? [],
       spanOutputProcessors: config.spanOutputProcessors ?? [],
+      bridge: config.bridge ?? void 0,
       includeInternalSpans: config.includeInternalSpans ?? false,
       requestContextKeys: config.requestContextKeys ?? []
     };
+    if (this.config.bridge?.init) {
+      this.config.bridge.init({ config: this.config });
+    }
   }
   /**
    * Override setLogger to add Observability specific initialization log
-   * and propagate logger to exporters
+   * and propagate logger to exporters and bridge
    */
   __setLogger(logger) {
     super.__setLogger(logger);
@@ -1540,8 +1815,11 @@ var BaseObservabilityInstance = class extends base.MastraBase {
         exporter.__setLogger(logger);
       }
     });
+    if (this.config.bridge?.__setLogger) {
+      this.config.bridge.__setLogger(logger);
+    }
     this.logger.debug(
-      `[Observability] Initialized [service=${this.config.serviceName}] [instance=${this.config.name}] [sampling=${this.config.sampling.type}]`
+      `[Observability] Initialized [service=${this.config.serviceName}] [instance=${this.config.name}] [sampling=${this.config.sampling?.type}] [bridge=${!!this.config.bridge}]`
     );
   }
   // ============================================================================
@@ -1570,11 +1848,15 @@ var BaseObservabilityInstance = class extends base.MastraBase {
     } else {
       traceState = this.computeTraceState(tracingOptions);
     }
-    const enrichedMetadata = this.extractMetadataFromRequestContext(requestContext, metadata, traceState);
+    const tracingMetadata = !options.parent ? tracingOptions?.metadata : void 0;
+    const mergedMetadata = metadata || tracingMetadata ? { ...metadata, ...tracingMetadata } : void 0;
+    const enrichedMetadata = this.extractMetadataFromRequestContext(requestContext, mergedMetadata, traceState);
+    const tags = !options.parent ? tracingOptions?.tags : void 0;
     const span = this.createSpan({
       ...rest,
       metadata: enrichedMetadata,
-      traceState
+      traceState,
+      tags
     });
     if (span.isEvent) {
       this.emitSpanEnded(span);
@@ -1608,6 +1890,12 @@ var BaseObservabilityInstance = class extends base.MastraBase {
   getSpanOutputProcessors() {
     return [...this.spanOutputProcessors];
   }
+  /**
+   * Get the bridge instance if configured
+   */
+  getBridge() {
+    return this.config.bridge;
+  }
   /**
    * Get the logger instance (for exporters and other components)
    */
@@ -1652,7 +1940,9 @@ var BaseObservabilityInstance = class extends base.MastraBase {
    */
   shouldSample(options) {
     const { sampling } = this.config;
-    switch (sampling.type) {
+    switch (sampling?.type) {
+      case void 0:
+        return true;
       case "always" /* ALWAYS */:
         return true;
       case "never" /* NEVER */:
@@ -1784,17 +2074,21 @@ var BaseObservabilityInstance = class extends base.MastraBase {
     }
   }
   /**
-   * Export tracing event through all exporters (realtime mode)
+   * Export tracing event through all exporters and bridge (realtime mode)
    */
   async exportTracingEvent(event) {
-    const exportPromises = this.exporters.map(async (exporter) => {
+    const targets = [
+      ...this.exporters
+    ];
+    if (this.config.bridge) {
+      targets.push(this.config.bridge);
+    }
+    const exportPromises = targets.map(async (target) => {
       try {
-        if (exporter.exportTracingEvent) {
-          await exporter.exportTracingEvent(event);
-          this.logger.debug(`[Observability] Event exported [exporter=${exporter.name}] [type=${event.type}]`);
-        }
+        await target.exportTracingEvent(event);
+        this.logger.debug(`[Observability] Event exported [target=${target.name}] [type=${event.type}]`);
       } catch (error) {
-        this.logger.error(`[Observability] Export error [exporter=${exporter.name}]`, error);
+        this.logger.error(`[Observability] Export error [target=${target.name}]`, error);
       }
     });
     await Promise.allSettled(exportPromises);
@@ -1818,6 +2112,9 @@ var BaseObservabilityInstance = class extends base.MastraBase {
       ...this.exporters.map((e) => e.shutdown()),
       ...this.spanOutputProcessors.map((p) => p.shutdown())
     ];
+    if (this.config.bridge) {
+      shutdownPromises.push(this.config.bridge.shutdown());
+    }
     await Promise.allSettled(shutdownPromises);
     this.logger.info(`[Observability] Shutdown completed [name=${this.name}]`);
   }
@@ -1964,9 +2261,16 @@ var SensitiveDataFilter = class {
   /**
    * Recursively filter objects/arrays for sensitive keys.
    * Handles circular references by replacing with a marker.
+   * Also attempts to parse and redact JSON strings.
    */
   deepFilter(obj, seen = /* @__PURE__ */ new WeakSet()) {
     if (obj === null || typeof obj !== "object") {
+      if (typeof obj === "string") {
+        const trimmed = obj.trim();
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+          return this.redactJsonString(obj);
+        }
+      }
       return obj;
     }
     if (seen.has(obj)) {
@@ -2019,6 +2323,22 @@ var SensitiveDataFilter = class {
       return normalizedKey === sensitiveField;
     });
   }
+  /**
+   * Attempt to parse a string as JSON and redact sensitive fields within it.
+   * If parsing fails or no sensitive data is found, returns the original string.
+   */
+  redactJsonString(str) {
+    try {
+      const parsed = JSON.parse(str);
+      if (parsed && typeof parsed === "object") {
+        const filtered = this.deepFilter(parsed, /* @__PURE__ */ new WeakSet());
+        return JSON.stringify(filtered);
+      }
+      return str;
+    } catch {
+      return str;
+    }
+  }
   /**
    * Redact a sensitive value.
    * - Full style: replaces with a fixed token.
@@ -2171,6 +2491,11 @@ var Observability = class extends base.MastraBase {
   }
 };
 
+// src/tracing-options.ts
+function buildTracingOptions(...updaters) {
+  return updaters.reduce((opts, updater) => updater(opts), {});
+}
+
 exports.BaseExporter = BaseExporter;
 exports.BaseObservabilityInstance = BaseObservabilityInstance;
 exports.BaseSpan = BaseSpan;
@@ -2184,7 +2509,10 @@ exports.NoOpSpan = NoOpSpan;
 exports.Observability = Observability;
 exports.SamplingStrategyType = SamplingStrategyType;
 exports.SensitiveDataFilter = SensitiveDataFilter;
+exports.TestExporter = TestExporter;
+exports.buildTracingOptions = buildTracingOptions;
 exports.deepClean = deepClean;
+exports.getExternalParentId = getExternalParentId;
 exports.observabilityConfigValueSchema = observabilityConfigValueSchema;
 exports.observabilityInstanceConfigSchema = observabilityInstanceConfigSchema;
 exports.observabilityRegistryConfigSchema = observabilityRegistryConfigSchema;