@mastra/observability 1.15.0-alpha.0 → 1.15.1-alpha.0

package/dist/index.js

@@ -2917,6 +2917,12 @@ var BaseObservabilityInstance = class extends MastraBase {
    * a span's `metadata.environment` isn't set.
    */
   #mastraEnvironment;
+  /**
+   * For excluded MODEL_GENERATION spans whose constructor clears `attributes`,
+   * we stash the lightweight provider/model from creation options so
+   * `captureExcludedModelUsage` can still build cost context.
+   */
+  #excludedModelMeta = /* @__PURE__ */ new WeakMap();
   constructor(config) {
     super({ component: RegisteredLogger.OBSERVABILITY, name: config.serviceName });
     this.config = {
@@ -3022,6 +3028,13 @@ var BaseObservabilityInstance = class extends MastraBase {
       tags,
       requestContext
     });
+    if (rest.type === SpanType.MODEL_GENERATION && this.config.excludeSpanTypes?.includes(SpanType.MODEL_GENERATION)) {
+      const attrs = rest.attributes;
+      const model = attrs?.responseModel ?? attrs?.model;
+      if (attrs?.provider || model) {
+        this.#excludedModelMeta.set(span, { provider: attrs?.provider, model });
+      }
+    }
     if (span.isEvent) {
       this.emitSpanEnded(span);
     } else {
@@ -3218,11 +3231,12 @@ var BaseObservabilityInstance = class extends MastraBase {
         return;
       }
       const rollupTarget = this.captureModelUsageRollup(span, options);
+      const excludedModelUsage = this.captureExcludedModelUsage(span, options);
       originalEnd(options);
       if (rollupTarget) {
         this.applyUsageRollup(rollupTarget);
       }
-      this.emitSpanEnded(span);
+      this.emitSpanEnded(span, excludedModelUsage);
     };
     span.update = (options) => {
       if (span.isEvent) {
@@ -3356,6 +3370,22 @@ var BaseObservabilityInstance = class extends MastraBase {
     }
     return exportedSpan;
   }
+  /** Export an already-processed span, returning undefined if filtered out. */
+  getProcessedSpanForExport(span) {
+    if (!span.isValid) return void 0;
+    if (span.isInternal && !this.config.includeInternalSpans) return void 0;
+    if (this.config.excludeSpanTypes?.includes(span.type)) return void 0;
+    const exportedSpan = span.exportSpan(this.config.includeInternalSpans);
+    if (!exportedSpan) return void 0;
+    if (this.config.spanFilter) {
+      try {
+        if (!this.config.spanFilter(exportedSpan)) return void 0;
+      } catch (error) {
+        this.logger.error(`[Observability] spanFilter error`, error);
+      }
+    }
+    return exportedSpan;
+  }
   /**
    * Emit a span started event.
    * Routes through the ObservabilityBus so exporters receive it via onTracingEvent.
@@ -3372,14 +3402,31 @@ var BaseObservabilityInstance = class extends MastraBase {
    * Emits any auto-extracted metrics while the live span tree is still available,
    * then routes the exported tracing event through the ObservabilityBus.
    */
-  emitSpanEnded(span) {
-    const exportedSpan = this.getSpanForExport(span);
-    if (exportedSpan) {
+  emitSpanEnded(span, excludedModelUsage) {
+    let processedSpan;
+    let spanWasProcessed = false;
+    if (span.isValid && !(span.isInternal && !this.config.includeInternalSpans)) {
+      processedSpan = this.processSpan(span);
+      spanWasProcessed = true;
       try {
-        emitAutoExtractedMetrics(span, this.getMetricsContext(span));
+        if (processedSpan) {
+          emitAutoExtractedMetrics(processedSpan, this.getMetricsContext(processedSpan));
+          const processedAttrs = processedSpan.attributes;
+          if (excludedModelUsage && !processedAttrs?.usage) {
+            emitTokenMetricsForUsage(
+              excludedModelUsage.usage,
+              excludedModelUsage.provider,
+              excludedModelUsage.model,
+              this.getMetricsContext(processedSpan)
+            );
+          }
+        }
       } catch (err) {
         this.logger.error("[Observability] Auto-extraction error:", err);
       }
+    }
+    const exportedSpan = spanWasProcessed ? processedSpan ? this.getProcessedSpanForExport(processedSpan) : void 0 : this.getSpanForExport(span);
+    if (exportedSpan) {
       const event = { type: TracingEventType.SPAN_ENDED, exportedSpan };
       this.emitTracingEvent(event);
     }
@@ -3415,6 +3462,26 @@ var BaseObservabilityInstance = class extends MastraBase {
     const model = endAttrs?.responseModel ?? endAttrs?.model ?? liveAttrs?.responseModel ?? liveAttrs?.model;
     return { ancestor, usage, provider, model };
   }
+  /**
+   * When a non-internal MODEL_GENERATION span is excluded by `excludeSpanTypes`,
+   * the BaseSpan constructor clears start-time attributes and DefaultSpan.end()
+   * drops end-time attributes before auto-extraction can read them. Capture
+   * usage from end options and provider/model from the creation-time stash so
+   * token and cost metrics still emit even though the trace span is filtered out.
+   */
+  captureExcludedModelUsage(span, endOptions) {
+    if (span.type !== SpanType.MODEL_GENERATION) return void 0;
+    if (span.isInternal) return void 0;
+    if (!this.config.excludeSpanTypes?.includes(SpanType.MODEL_GENERATION)) return void 0;
+    const endAttrs = endOptions?.attributes ?? void 0;
+    const liveAttrs = span.attributes;
+    const usage = endAttrs?.usage ?? liveAttrs?.usage;
+    if (!usage) return void 0;
+    const stashed = this.#excludedModelMeta.get(span);
+    const provider = endAttrs?.provider ?? liveAttrs?.provider ?? stashed?.provider;
+    const model = endAttrs?.responseModel ?? endAttrs?.model ?? liveAttrs?.responseModel ?? liveAttrs?.model ?? stashed?.model;
+    return { usage, provider, model };
+  }
   /**
    * Accumulate usage onto the ancestor's `internalUsage` attribute (for trace
    * UI visibility) and emit auto-extracted token metrics now, using the