@mastra/observability 1.11.1 → 1.12.0-alpha.1

package/dist/index.cjs

@@ -10,6 +10,7 @@ var fs = require('fs');
 var module$1 = require('module');
 var path = require('path');
 var web = require('stream/web');
+var features = require('@mastra/core/features');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -45,6 +46,23 @@ function routeToHandler(handler, event, logger) {
         if (handler.onScoreEvent) {
           return catchAsyncResult(handler.onScoreEvent(event), handler.name, "score", logger);
         }
+        if (handler.addScoreToTrace) {
+          const score = event.score;
+          if (!score.traceId) break;
+          return catchAsyncResult(
+            handler.addScoreToTrace({
+              traceId: score.traceId,
+              ...score.spanId ? { spanId: score.spanId } : {},
+              score: score.score,
+              ...score.reason ? { reason: score.reason } : {},
+              scorerName: score.scorerName ?? score.scorerId,
+              ...score.metadata ? { metadata: score.metadata } : {}
+            }),
+            handler.name,
+            "score",
+            logger
+          );
+        }
         break;
       case "feedback":
         if (handler.onFeedbackEvent) {
@@ -56,6 +74,15 @@ function routeToHandler(handler, event, logger) {
     logger.error(`[Observability] Handler error [handler=${handler.name}]:`, err);
   }
 }
+function routeDropToHandler(handler, event, logger) {
+  try {
+    if (handler.onDroppedEvent) {
+      return catchAsyncResult(handler.onDroppedEvent(event), handler.name, "drop", logger);
+    }
+  } catch (err) {
+    logger.error(`[Observability] Handler error [handler=${handler.name}]:`, err);
+  }
+}
 function catchAsyncResult(result, handlerName, signal, logger) {
   if (result && typeof result.then === "function") {
     return result.catch((err) => {
@@ -13905,12 +13932,18 @@ var observabilityConfigValueSchema = external_exports.object(observabilityInstan
     message: "At least one exporter or a bridge is required"
   }
 );
+var sensitiveDataFilterOptionsSchema = external_exports.object({
+  sensitiveFields: external_exports.array(external_exports.string()).optional(),
+  redactionToken: external_exports.string().optional(),
+  redactionStyle: external_exports.enum(["full", "partial"]).optional()
+}).strict();
 var observabilityRegistryConfigSchema = external_exports.object({
   default: external_exports.object({
     enabled: external_exports.boolean().optional()
   }).optional().nullable(),
   configs: external_exports.union([external_exports.record(external_exports.string(), external_exports.any()), external_exports.array(external_exports.any()), external_exports.null()]).optional(),
-  configSelector: external_exports.function().optional()
+  configSelector: external_exports.function().optional(),
+  sensitiveDataFilter: external_exports.union([external_exports.boolean(), sensitiveDataFilterOptionsSchema]).optional()
 }).passthrough().refine(
   (data) => {
     const isDefaultEnabled = data.default?.enabled === true;
@@ -15680,31 +15713,39 @@ var EventBuffer = class {
         break;
     }
   }
-  /** Re-add failed create events to the buffer, dropping those that exceed max retries. */
+  /** Re-add failed create events to the buffer, returning events that exceed max retries. */
   reAddCreates(events) {
     const retryable = [];
+    const dropped = [];
     for (const e of events) {
       if (++e.retryCount <= this.#maxRetries) {
         retryable.push(e);
+      } else {
+        dropped.push(e);
       }
     }
     if (retryable.length > 0) {
       this.setFirstEventTime();
       this.#creates.push(...retryable);
     }
+    return dropped;
   }
-  /** Re-add failed update events to the buffer, dropping those that exceed max retries. */
+  /** Re-add failed update events to the buffer, returning events that exceed max retries. */
   reAddUpdates(events) {
     const retryable = [];
+    const dropped = [];
     for (const e of events) {
       if (++e.retryCount <= this.#maxRetries) {
         retryable.push(e);
+      } else {
+        dropped.push(e);
       }
     }
     if (retryable.length > 0) {
       this.setFirstEventTime();
       this.#updates.push(...retryable);
     }
+    return dropped;
   }
   /** Snapshot of buffered create events. */
   get creates() {
@@ -15783,6 +15824,7 @@ var DefaultExporter = class extends BaseExporter {
   #observabilityStorage;
   #resolvedStrategy;
   #flushTimer;
+  #emitDropEvent;
   // Signals whose storage methods threw "not implemented" — skip on future flushes
   #unsupportedSignals = /* @__PURE__ */ new Set();
   constructor(config2 = {}) {
@@ -15804,6 +15846,7 @@ var DefaultExporter = class extends BaseExporter {
   async init(options) {
     try {
       this.#isInitializing = true;
+      this.#emitDropEvent = options.emitDropEvent;
       this.#storage = options.mastra?.getStorage();
       if (!this.#storage) {
         this.logger.warn("DefaultExporter disabled: Storage not available. Traces will not be persisted.");
@@ -15889,21 +15932,54 @@ var DefaultExporter = class extends BaseExporter {
       this.scheduleFlush();
     }
   }
+  sanitizeDropError(error48) {
+    if (error48 instanceof error$1.MastraError) {
+      return {
+        id: error48.id,
+        domain: String(error48.domain),
+        message: error48.message
+      };
+    }
+    if (error48 instanceof Error) {
+      return { message: error48.message };
+    }
+    return { message: String(error48) };
+  }
+  emitDrop(signal, reason, count, error48) {
+    if (count === 0) return;
+    const dropEvent = {
+      type: "drop",
+      signal,
+      reason,
+      count,
+      timestamp: /* @__PURE__ */ new Date(),
+      exporterName: this.name,
+      ...this.#observabilityStorage ? { storageName: this.#observabilityStorage.constructor.name } : {},
+      ...error48 === void 0 ? {} : { error: this.sanitizeDropError(error48) }
+    };
+    this.#emitDropEvent?.(dropEvent);
+  }
   /**
    * Flush a batch of create events for a single signal type.
    * On "not implemented" errors, disables the signal for future flushes.
    * On other errors, re-adds events to the buffer for retry.
    */
   async flushCreates(signal, events, storageCall) {
-    if (this.#unsupportedSignals.has(signal) || events.length === 0) return;
+    if (events.length === 0) return;
+    if (this.#unsupportedSignals.has(signal)) {
+      this.emitDrop(signal, "unsupported-storage", events.length);
+      return;
+    }
     try {
       await storageCall(events);
     } catch (error48) {
       if (error48 instanceof error$1.MastraError && error48.domain === error$1.ErrorDomain.MASTRA_OBSERVABILITY && error48.id.endsWith("_NOT_IMPLEMENTED")) {
         this.logger.warn(error48.message);
         this.#unsupportedSignals.add(signal);
+        this.emitDrop(signal, "unsupported-storage", events.length, error48);
       } else {
-        this.#eventBuffer.reAddCreates(events);
+        const dropped = this.#eventBuffer.reAddCreates(events);
+        this.emitDrop(signal, "retry-exhausted", dropped.length, error48);
       }
     }
   }
@@ -15912,7 +15988,12 @@ var DefaultExporter = class extends BaseExporter {
    * When `isEnd` is true, successfully flushed spans are removed from tracking.
    */
   async flushSpanUpdates(events, deferredUpdates, isEnd) {
-    if (this.#unsupportedSignals.has("tracing") || events.length === 0) return;
+    const deferredCountAtEntry = deferredUpdates.length;
+    if (events.length === 0) return;
+    if (this.#unsupportedSignals.has("tracing")) {
+      this.emitDrop("tracing", "unsupported-storage", events.length);
+      return;
+    }
     const partials = [];
     for (const event of events) {
       const span = event.exportedSpan;
@@ -15936,9 +16017,12 @@ var DefaultExporter = class extends BaseExporter {
       if (error48 instanceof error$1.MastraError && error48.domain === error$1.ErrorDomain.MASTRA_OBSERVABILITY && error48.id.endsWith("_NOT_IMPLEMENTED")) {
         this.logger.warn(error48.message);
         this.#unsupportedSignals.add("tracing");
+        deferredUpdates.length = 0;
+        this.emitDrop("tracing", "unsupported-storage", events.length + deferredCountAtEntry, error48);
       } else {
         deferredUpdates.length = 0;
-        this.#eventBuffer.reAddUpdates(events);
+        const dropped = this.#eventBuffer.reAddUpdates(events);
+        this.emitDrop("tracing", "retry-exhausted", dropped.length, error48);
       }
     }
   }
@@ -16014,17 +16098,17 @@ var DefaultExporter = class extends BaseExporter {
         (events) => this.#observabilityStorage.batchCreateFeedback({ feedbacks: events.map((f) => storage.buildFeedbackRecord(f)) })
       ),
       this.flushCreates(
-        "logs",
+        "log",
         createLogEvents,
         (events) => this.#observabilityStorage.batchCreateLogs({ logs: events.map((l) => storage.buildLogRecord(l)) })
       ),
       this.flushCreates(
-        "metrics",
+        "metric",
         createMetricEvents,
         (events) => this.#observabilityStorage.batchCreateMetrics({ metrics: events.map((m) => storage.buildMetricRecord(m)) })
       ),
       this.flushCreates(
-        "scores",
+        "score",
         createScoreEvents,
         (events) => this.#observabilityStorage.batchCreateScores({ scores: events.map((s) => storage.buildScoreRecord(s)) })
       ),
@@ -16038,7 +16122,13 @@ var DefaultExporter = class extends BaseExporter {
     await this.flushSpanUpdates(updateSpanEvents, deferredUpdates, false);
     await this.flushSpanUpdates(endSpanEvents, deferredUpdates, true);
     if (deferredUpdates.length > 0) {
-      this.#eventBuffer.reAddUpdates(deferredUpdates);
+      if (this.#unsupportedSignals.has("tracing")) {
+        this.emitDrop("tracing", "unsupported-storage", deferredUpdates.length);
+        deferredUpdates.length = 0;
+      } else {
+        const dropped = this.#eventBuffer.reAddUpdates(deferredUpdates);
+        this.emitDrop("tracing", "retry-exhausted", dropped.length);
+      }
     }
     const elapsed = Date.now() - startTime;
     this.logger.debug("Batch flushed", {
@@ -17667,6 +17757,8 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
   bridge;
   /** In-flight handler promises from routeToHandler. Self-cleaning via .finally(). */
   pendingHandlers = /* @__PURE__ */ new Set();
+  handlerBufferFlushDepth = 0;
+  dropEventsEmittedDuringHandlerFlush = 0;
   /** Resolved deepClean options applied to non-tracing events before fan-out. */
   deepCleanOptions;
   constructor(opts) {
@@ -17753,6 +17845,23 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
     }
     super.emit(cleaned);
   }
+  /**
+   * Emit exporter pipeline drop events to exporters and the bridge.
+   *
+   * Drop events describe exporter health, not user observability data, so they
+   * are intentionally not delivered to generic event-bus subscribers.
+   */
+  emitDropEvent(event) {
+    if (this.handlerBufferFlushDepth > 0) {
+      this.dropEventsEmittedDuringHandlerFlush++;
+    }
+    for (const exporter of this.exporters) {
+      this.trackPromise(routeDropToHandler(exporter, event, this.logger));
+    }
+    if (this.bridge) {
+      this.trackPromise(routeDropToHandler(this.bridge, event, this.logger));
+    }
+  }
   /**
    * Track an async handler promise so flush() can await it.
    * No-ops for sync (void) results.
@@ -17764,19 +17873,8 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
       void promise2.finally(() => this.pendingHandlers.delete(promise2));
     }
   }
-  /**
-   * Two-phase flush to ensure all observability data is fully exported.
-   *
-   * **Phase 1 — Delivery:** Await all in-flight handler promises (exporters,
-   * bridge, and base-class subscribers). After this resolves, all event data
-   * has been delivered to handler methods.
-   *
-   * **Phase 2 — Buffer drain:** Call flush() on each exporter and bridge to
-   * drain their SDK-internal buffers (e.g., OTEL BatchSpanProcessor, Langfuse
-   * client queue). Phases are sequential — Phase 2 must not start until
-   * Phase 1 completes, otherwise exporters would flush empty buffers.
-   */
-  async flush() {
+  /** Await in-flight routed handler promises, draining until empty. */
+  async drainPendingHandlers() {
     let iterations = 0;
     while (this.pendingHandlers.size > 0) {
       await Promise.allSettled([...this.pendingHandlers]);
@@ -17791,14 +17889,54 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
         break;
       }
     }
-    await super.flush();
-    const bufferFlushPromises = this.exporters.map((e) => e.flush());
-    if (this.bridge) {
-      bufferFlushPromises.push(this.bridge.flush());
+  }
+  /** Drain exporter and bridge SDK-internal buffers. */
+  async flushHandlerBuffers() {
+    const initialDropCount = this.dropEventsEmittedDuringHandlerFlush;
+    this.handlerBufferFlushDepth++;
+    try {
+      const bufferFlushPromises = this.exporters.map((e) => e.flush());
+      if (this.bridge) {
+        bufferFlushPromises.push(this.bridge.flush());
+      }
+      if (bufferFlushPromises.length > 0) {
+        await Promise.allSettled(bufferFlushPromises);
+      }
+      return this.dropEventsEmittedDuringHandlerFlush > initialDropCount;
+    } finally {
+      this.handlerBufferFlushDepth--;
     }
-    if (bufferFlushPromises.length > 0) {
-      await Promise.allSettled(bufferFlushPromises);
+  }
+  /**
+   * Multi-phase flush to ensure all observability data is fully exported.
+   *
+   * **Phase 1 — Delivery:** Await all in-flight handler promises (exporters,
+   * bridge, and base-class subscribers). After this resolves, all event data
+   * has been delivered to handler methods.
+   *
+   * **Phase 2 — Buffer drain:** Call flush() on each exporter and bridge to
+   * drain their SDK-internal buffers (e.g., OTEL BatchSpanProcessor, Langfuse
+   * client queue). Phases are sequential — buffer drains must not start until
+   * delivery completes, otherwise exporters would flush empty buffers.
+   *
+   * Exporter flushes can emit drop events. When that happens, flush loops
+   * through delivery and buffer drain again so alerting integrations that buffer
+   * drop notifications are drained before returning.
+   */
+  async flush() {
+    await this.drainPendingHandlers();
+    await super.flush();
+    for (let iterations = 0; iterations < MAX_FLUSH_ITERATIONS; iterations++) {
+      const emittedDropEvents = await this.flushHandlerBuffers();
+      if (!emittedDropEvents && this.pendingHandlers.size === 0) {
+        return;
+      }
+      await this.drainPendingHandlers();
+      await super.flush();
     }
+    this.logger.error(
+      `[ObservabilityBus] flush() exceeded ${MAX_FLUSH_ITERATIONS} buffer drain iterations. Handlers may be emitting drop events during every flush.`
+    );
   }
   /** Flush all pending events and exporter buffers, then clear subscribers. */
   async shutdown() {
@@ -18157,8 +18295,19 @@ function normalizeProvider(provider) {
   return dotIndex !== -1 ? normalized.substring(0, dotIndex) : normalized;
 }
 function getModelVariants(model) {
-  const dashed = model.replace(/\./g, "-");
-  return [model, dashed, stripDateSuffix(model), stripDateSuffix(dashed)];
+  const variants = /* @__PURE__ */ new Set();
+  const add = (v) => {
+    variants.add(v);
+    variants.add(stripDateSuffix(v));
+  };
+  add(model);
+  add(model.replace(/\./g, "-"));
+  add(model.replace(/[./]/g, "-"));
+  const slashIndex = model.indexOf("/");
+  if (slashIndex !== -1) {
+    add(model.substring(slashIndex + 1));
+  }
+  return [...variants];
 }
 function stripDateSuffix(model) {
   let stripped = model.replace(/-20\d{2}-\d{2}-\d{2}$/, "");
@@ -18601,6 +18750,9 @@ function sumDefinedValues(obj, keys) {
 }
 
 // src/model-tracing.ts
+function supportsModelInference() {
+  return features.coreFeatures.has("model-inference-span");
+}
 function formatPreviewLabel(label, fallback) {
   return typeof label === "string" && label.length > 0 ? label : fallback;
 }
@@ -18759,6 +18911,7 @@ function extractStepInput(payload) {
 var ModelSpanTracker = class {
   #modelSpan;
   #currentStepSpan;
+  #currentInferenceSpan;
   #currentChunkSpan;
   #currentChunkType;
   #accumulator = {};
@@ -18770,9 +18923,18 @@ var ModelSpanTracker = class {
   #deferStepClose = false;
   /** Stored step-finish payload when defer mode is enabled */
   #pendingStepFinishPayload;
+  /** Static request-side context applied to every MODEL_INFERENCE span */
+  #inferenceContext;
   constructor(modelSpan) {
     this.#modelSpan = modelSpan;
   }
+  /**
+   * Set request-side context applied to subsequent MODEL_INFERENCE spans.
+   * No-op when paired with an older @mastra/core that lacks the feature flag.
+   */
+  setInferenceContext(context) {
+    this.#inferenceContext = context;
+  }
   /**
    * Capture the completion start time (time to first token) when the first content chunk arrives.
    */
@@ -18854,6 +19016,11 @@ var ModelSpanTracker = class {
    * Start a new Model execution step.
    * This should be called at the beginning of LLM execution to capture accurate startTime.
    * The step-start chunk payload can be passed later via updateStep() if needed.
+   *
+   * Note: this only opens MODEL_STEP. The MODEL_INFERENCE child span is opened
+   * separately via startInference() so its duration excludes input processor work.
+   * Callers that don't call startInference() explicitly will get one auto-created
+   * when the first model chunk arrives.
    */
   startStep(payload) {
     if (this.#currentStepSpan) {
@@ -18873,6 +19040,71 @@ var ModelSpanTracker = class {
     this.#currentStepInputIsFinal = Array.isArray(payload?.inputMessages);
     this.#chunkSequence = 0;
   }
+  /**
+   * End the current MODEL_INFERENCE span when the provider stream finishes.
+   * Fields are duplicated onto MODEL_STEP (in #endStepSpan) so existing
+   * integrations that read usage/finishReason from the step span continue
+   * to work unchanged.
+   *
+   * Safe to call multiple times - no-ops if the span is already closed.
+   */
+  #endInferenceSpan(payload) {
+    if (!this.#currentInferenceSpan) return;
+    const { usage: rawUsage, ...otherOutput } = payload.output;
+    const usage = extractUsageMetrics(rawUsage, payload.metadata?.providerMetadata);
+    this.#currentInferenceSpan.end({
+      output: otherOutput,
+      attributes: {
+        usage,
+        finishReason: payload.stepResult.reason,
+        warnings: payload.stepResult.warnings,
+        completionStartTime: this.#completionStartTime
+      }
+    });
+    this.#currentInferenceSpan = void 0;
+  }
+  /**
+   * Open the MODEL_INFERENCE span for the current step. Chunks (including tool-call
+   * chunks emitted by the model) parent under this span so its duration reflects
+   * pure model latency.
+   *
+   * Should be called immediately before invoking the model — after any input
+   * processors / `prepareStep` work has completed — so the span's startTime
+   * does not include processor time. The latest `#inferenceContext` (set via
+   * setInferenceContext) is snapshotted onto the span at creation.
+   *
+   * No-ops when the installed @mastra/core lacks the `model-inference-span`
+   * feature flag, or when called without an active step span. Auto-invoked from
+   * chunk handlers as a safety net; explicit callers get the most accurate
+   * start time.
+   */
+  startInference(payload) {
+    if (!supportsModelInference()) {
+      return;
+    }
+    if (!this.#currentStepSpan || this.#currentInferenceSpan) {
+      return;
+    }
+    const input = extractStepInput(payload);
+    const generationAttrs = this.#modelSpan?.attributes;
+    const ctx = this.#inferenceContext;
+    this.#currentInferenceSpan = this.#currentStepSpan.createChildSpan({
+      name: `inference: ${this.#stepIndex}`,
+      type: observability.SpanType.MODEL_INFERENCE,
+      attributes: {
+        stepIndex: this.#stepIndex,
+        model: generationAttrs?.model,
+        provider: generationAttrs?.provider,
+        streaming: generationAttrs?.streaming,
+        ...ctx?.parameters !== void 0 ? { parameters: ctx.parameters } : {},
+        ...ctx?.providerOptions !== void 0 ? { providerOptions: ctx.providerOptions } : {},
+        ...ctx?.availableTools !== void 0 ? { availableTools: ctx.availableTools } : {},
+        ...ctx?.toolChoice !== void 0 ? { toolChoice: ctx.toolChoice } : {},
+        ...ctx?.responseFormat !== void 0 ? { responseFormat: ctx.responseFormat } : {}
+      },
+      input
+    });
+  }
   /**
    * Update the current step span with additional payload data.
    * Called when step-start chunk arrives with request/warnings info.
@@ -18911,6 +19143,7 @@ var ModelSpanTracker = class {
         delete cleanMetadata[key];
       }
     }
+    this.#endInferenceSpan(payload);
     this.#currentStepSpan.end({
       output: otherOutput,
       attributes: {
@@ -18928,14 +19161,35 @@ var ModelSpanTracker = class {
     this.#stepIndex++;
   }
   /**
-   * Create a new chunk span (for multi-part chunks like text-start/delta/end)
+   * Returns the parent span for chunks. Chunks parent under MODEL_INFERENCE
+   * (the provider call) when available, falling back to MODEL_STEP only if
+   * startStep() was bypassed.
    */
-  #startChunkSpan(chunkType, initialData) {
-    this.#endChunkSpan();
+  #chunkParent() {
+    return this.#currentInferenceSpan ?? this.#currentStepSpan;
+  }
+  /**
+   * Safety-net invoked from chunk handlers: auto-create MODEL_STEP and
+   * MODEL_INFERENCE if a chunk arrives before the loop has explicitly opened
+   * them, so chunks parent under MODEL_INFERENCE rather than falling through
+   * to MODEL_STEP. Idempotent — each public start* method is itself a no-op
+   * when its span is already live.
+   */
+  #ensureStepAndInference() {
     if (!this.#currentStepSpan) {
       this.startStep();
     }
-    this.#currentChunkSpan = this.#currentStepSpan?.createChildSpan({
+    if (!this.#currentInferenceSpan) {
+      this.startInference();
+    }
+  }
+  /**
+   * Create a new chunk span (for multi-part chunks like text-start/delta/end)
+   */
+  #startChunkSpan(chunkType, initialData) {
+    this.#endChunkSpan();
+    this.#ensureStepAndInference();
+    this.#currentChunkSpan = this.#chunkParent()?.createChildSpan({
       name: `chunk: '${chunkType}'`,
       type: observability.SpanType.MODEL_CHUNK,
       attributes: {
@@ -18974,10 +19228,8 @@ var ModelSpanTracker = class {
    * Create an event span (for single chunks like tool-call)
    */
   #createEventSpan(chunkType, output, options) {
-    if (!this.#currentStepSpan) {
-      this.startStep();
-    }
-    const span = this.#currentStepSpan?.createEventSpan({
+    this.#ensureStepAndInference();
+    const span = this.#chunkParent()?.createEventSpan({
       name: `chunk: '${chunkType}'`,
       type: observability.SpanType.MODEL_CHUNK,
       attributes: {
@@ -19098,10 +19350,8 @@ var ModelSpanTracker = class {
   #handleToolApprovalChunk(chunk) {
     if (chunk.type !== "tool-call-approval") return;
     const payload = chunk.payload;
-    if (!this.#currentStepSpan) {
-      this.startStep();
-    }
-    const span = this.#currentStepSpan?.createEventSpan({
+    this.#ensureStepAndInference();
+    const span = this.#chunkParent()?.createEventSpan({
       name: `chunk: 'tool-call-approval'`,
       type: observability.SpanType.MODEL_CHUNK,
       attributes: {
@@ -19159,10 +19409,15 @@ var ModelSpanTracker = class {
               } else {
                 this.startStep(chunk.payload);
               }
+              if (!this.#currentInferenceSpan) {
+                this.startInference(chunk.payload);
+              }
               break;
             case "step-finish":
               if (this.#deferStepClose) {
                 this.#pendingStepFinishPayload = chunk.payload;
+                this.#endChunkSpan();
+                this.#endInferenceSpan(chunk.payload);
               } else {
                 this.#endStepSpan(chunk.payload);
               }
@@ -19258,6 +19513,7 @@ function isSpanInternal(spanType, flags) {
     // Model-related spans
     case observability.SpanType.MODEL_GENERATION:
     case observability.SpanType.MODEL_STEP:
+    case observability.SpanType.MODEL_INFERENCE:
     case observability.SpanType.MODEL_CHUNK:
       return (flags & observability.InternalSpans.MODEL) !== 0;
     // Default: never internal
@@ -20350,6 +20606,7 @@ function buildScoreEvent(args) {
       traceId,
       spanId,
       scorerId: score.scorerId,
+      scorerName: score.scorerName,
       scorerVersion: score.scorerVersion,
       source: score.source,
       scoreSource: score.scoreSource,
@@ -20357,6 +20614,7 @@ function buildScoreEvent(args) {
       reason: score.reason,
       experimentId: score.experimentId,
       scoreTraceId: score.scoreTraceId,
+      targetEntityType: score.targetEntityType,
       correlationContext,
       metadata: mergeMetadata(inheritedMetadata, score.metadata)
     }
@@ -20887,23 +21145,56 @@ var Observability = class extends base.MastraBase {
         }
       }
     }
+    const sensitiveDataFilterSetting = config2.sensitiveDataFilter ?? true;
+    const shouldAutoApplySensitiveFilter = sensitiveDataFilterSetting !== false;
+    const sensitiveDataFilterOptions = typeof sensitiveDataFilterSetting === "object" && sensitiveDataFilterSetting !== null ? sensitiveDataFilterSetting : void 0;
+    const buildAutoSensitiveFilter = () => {
+      if (!shouldAutoApplySensitiveFilter) {
+        return void 0;
+      }
+      return new SensitiveDataFilter(sensitiveDataFilterOptions);
+    };
     if (config2.default?.enabled) {
       console.warn(
-        '[Mastra Observability] The "default: { enabled: true }" configuration is deprecated and will be removed in a future version. Please use explicit configs with DefaultExporter, CloudExporter, and SensitiveDataFilter instead. See https://mastra.ai/docs/observability/tracing/overview for the recommended configuration.'
+        '[Mastra Observability] The "default: { enabled: true }" configuration is deprecated and will be removed in a future version. Please use explicit configs with DefaultExporter and CloudExporter instead. Sensitive data filtering is applied by default and can be controlled via the top-level "sensitiveDataFilter" option. See https://mastra.ai/docs/observability/tracing/overview for the recommended configuration.'
       );
+      const autoFilter = buildAutoSensitiveFilter();
       const defaultInstance = new DefaultObservabilityInstance({
         serviceName: "mastra",
         name: "default",
         sampling: { type: "always" /* ALWAYS */ },
         exporters: [new DefaultExporter(), new CloudExporter()],
-        spanOutputProcessors: [new SensitiveDataFilter()]
+        spanOutputProcessors: autoFilter ? [autoFilter] : []
       });
       this.#registry.register("default", defaultInstance, true);
     }
     if (config2.configs) {
       const instances = Object.entries(config2.configs);
       instances.forEach(([name, tracingDef], index) => {
-        const instance = isInstance(tracingDef) ? tracingDef : new DefaultObservabilityInstance({ ...tracingDef, name });
+        let instance;
+        if (isInstance(tracingDef)) {
+          instance = tracingDef;
+          if (shouldAutoApplySensitiveFilter) {
+            const processors = instance.getSpanOutputProcessors?.() ?? [];
+            const hasFilter = processors.some((p) => p instanceof SensitiveDataFilter);
+            if (!hasFilter) {
+              this.logger?.warn(
+                "[Mastra Observability] Pre-instantiated observability instance does not include a SensitiveDataFilter. Auto-applied filtering is skipped for pre-instantiated instances. Add a SensitiveDataFilter to spanOutputProcessors when constructing the instance to redact sensitive data.",
+                { instanceName: name }
+              );
+            }
+          }
+        } else {
+          const userProcessors = tracingDef.spanOutputProcessors ?? [];
+          const hasFilter = userProcessors.some((p) => p instanceof SensitiveDataFilter);
+          const autoFilter = !hasFilter ? buildAutoSensitiveFilter() : void 0;
+          const spanOutputProcessors = autoFilter ? [...userProcessors, autoFilter] : userProcessors;
+          instance = new DefaultObservabilityInstance({
+            ...tracingDef,
+            name,
+            spanOutputProcessors
+          });
+        }
         const isDefault = !config2.default?.enabled && index === 0;
         this.#registry.register(name, instance, isDefault);
       });
@@ -20922,10 +21213,11 @@ var Observability = class extends base.MastraBase {
       instance.__setMastraEnvironment?.(mastraEnvironment);
       const config2 = instance.getConfig();
       const exporters = instance.getExporters();
+      const emitDropEvent = instance instanceof BaseObservabilityInstance ? (event) => instance.getObservabilityBus().emitDropEvent(event) : void 0;
       exporters.forEach((exporter) => {
         if ("init" in exporter && typeof exporter.init === "function") {
           try {
-            exporter.init({ mastra, config: config2 });
+            exporter.init({ mastra, config: config2, emitDropEvent });
           } catch (error48) {
             this.logger?.warn("Failed to initialize observability exporter", {
               exporterName: exporter.name,
@@ -21113,6 +21405,9 @@ var Observability = class extends base.MastraBase {
   }
 };
 
+// src/features.ts
+var observabilityFeatures = /* @__PURE__ */ new Set(["model-inference-span"]);
+
 // src/tracing-options.ts
 function buildTracingOptions(...updaters) {
   return updaters.reduce((opts, updater) => updater(opts), {});
@@ -21149,6 +21444,7 @@ exports.getExternalParentId = getExternalParentId;
 exports.isSerializedMap = isSerializedMap;
 exports.mergeSerializationOptions = mergeSerializationOptions;
 exports.observabilityConfigValueSchema = observabilityConfigValueSchema;
+exports.observabilityFeatures = observabilityFeatures;
 exports.observabilityInstanceConfigSchema = observabilityInstanceConfigSchema;
 exports.observabilityRegistryConfigSchema = observabilityRegistryConfigSchema;
 exports.reconstructSerializedMap = reconstructSerializedMap;