@mastra/observability 1.4.0 → 1.5.0

package/dist/index.js

@@ -3,6 +3,7 @@ import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { ConsoleLogger, LogLevel, RegisteredLogger } from '@mastra/core/logger';
 import { TracingEventType, SpanType, DEFAULT_BLOCKED_LABELS, InternalSpans } from '@mastra/core/observability';
 import { fetchWithRetry, getNestedValue, setNestedValue } from '@mastra/core/utils';
+import { buildUpdateSpanRecord, buildFeedbackRecord, buildLogRecord, buildMetricRecord, buildScoreRecord, buildCreateSpanRecord } from '@mastra/core/storage';
 import { TransformStream } from 'stream/web';
 
 var __defProp = Object.defineProperty;
@@ -13811,7 +13812,8 @@ var observabilityInstanceConfigSchema = external_exports.object({
   spanOutputProcessors: external_exports.array(external_exports.any()).optional(),
   includeInternalSpans: external_exports.boolean().optional(),
   requestContextKeys: external_exports.array(external_exports.string()).optional(),
-  serializationOptions: serializationOptionsSchema
+  serializationOptions: serializationOptionsSchema,
+  cardinality: external_exports.any().optional()
 }).refine(
   (data) => {
     const hasExporters = data.exporters && data.exporters.length > 0;
@@ -15260,44 +15262,197 @@ var ConsoleExporter = class extends BaseExporter {
     this.logger.info("ConsoleExporter shutdown");
   }
 };
-function resolveTracingStorageStrategy(config2, observability, storageName, logger) {
+var EventBuffer = class {
+  #preInit = [];
+  #creates = [];
+  #updates = [];
+  #allCreatedSpans = /* @__PURE__ */ new Set();
+  #firstEventTime;
+  #storageStrategy;
+  #maxRetries;
+  constructor(args) {
+    this.#maxRetries = args.maxRetries;
+  }
+  /** Initialize with a storage strategy and replay any pre-init events. */
+  init(args) {
+    if (!this.#storageStrategy) {
+      this.#storageStrategy = args.strategy;
+      for (const event of this.#preInit) {
+        this.addEvent(event);
+      }
+      this.#preInit = [];
+    }
+  }
+  /** Clear the create and update buffers and reset the event timer. */
+  reset() {
+    this.#creates = [];
+    this.#updates = [];
+    this.#firstEventTime = void 0;
+  }
+  setFirstEventTime() {
+    if (!this.#firstEventTime) {
+      this.#firstEventTime = /* @__PURE__ */ new Date();
+    }
+  }
+  pushCreate(event) {
+    this.setFirstEventTime();
+    this.#creates.push({ ...event, retryCount: 0 });
+  }
+  pushUpdate(event) {
+    this.setFirstEventTime();
+    this.#updates.push({ ...event, retryCount: 0 });
+  }
+  /** Route an event to the create or update buffer based on its type and the storage strategy. */
+  addEvent(event) {
+    if (!this.#storageStrategy) {
+      this.#preInit.push({ ...event, retryCount: 0 });
+      return;
+    }
+    switch (event.type) {
+      case TracingEventType.SPAN_STARTED:
+        switch (this.#storageStrategy) {
+          case "realtime":
+          case "event-sourced":
+          case "batch-with-updates":
+            this.pushCreate(event);
+            break;
+        }
+        break;
+      case TracingEventType.SPAN_UPDATED:
+        switch (this.#storageStrategy) {
+          case "realtime":
+          case "batch-with-updates":
+            this.pushUpdate(event);
+            break;
+        }
+        break;
+      case TracingEventType.SPAN_ENDED:
+        if (event.exportedSpan.isEvent) {
+          this.pushCreate(event);
+        } else {
+          switch (this.#storageStrategy) {
+            case "realtime":
+            case "batch-with-updates":
+              this.pushUpdate(event);
+              break;
+            default:
+              this.pushCreate(event);
+              break;
+          }
+        }
+        break;
+      default:
+        this.pushCreate(event);
+        break;
+    }
+  }
+  /** Re-add failed create events to the buffer, dropping those that exceed max retries. */
+  reAddCreates(events) {
+    const retryable = [];
+    for (const e of events) {
+      if (++e.retryCount <= this.#maxRetries) {
+        retryable.push(e);
+      }
+    }
+    if (retryable.length > 0) {
+      this.setFirstEventTime();
+      this.#creates.push(...retryable);
+    }
+  }
+  /** Re-add failed update events to the buffer, dropping those that exceed max retries. */
+  reAddUpdates(events) {
+    const retryable = [];
+    for (const e of events) {
+      if (++e.retryCount <= this.#maxRetries) {
+        retryable.push(e);
+      }
+    }
+    if (retryable.length > 0) {
+      this.setFirstEventTime();
+      this.#updates.push(...retryable);
+    }
+  }
+  /** Snapshot of buffered create events. */
+  get creates() {
+    return [...this.#creates];
+  }
+  /** Snapshot of buffered update events. */
+  get updates() {
+    return [...this.#updates];
+  }
+  /** Total number of buffered events (creates + updates). */
+  get totalSize() {
+    return this.#creates.length + this.#updates.length;
+  }
+  /** Milliseconds since the first event was buffered in the current batch. */
+  get elapsed() {
+    if (!this.#firstEventTime) {
+      return 0;
+    }
+    return Date.now() - this.#firstEventTime.getTime();
+  }
+  /**
+   * Builds a unique span key for tracking
+   */
+  buildSpanKey(span) {
+    return `${span.traceId}:${span.spanId}`;
+  }
+  /** Track successfully created spans so updates can verify span existence before flushing. */
+  addCreatedSpans(args) {
+    if (this.#storageStrategy === "event-sourced" || this.#storageStrategy === "insert-only") {
+      return;
+    }
+    for (const createRecord of args.records) {
+      if (!createRecord.isEvent) {
+        this.#allCreatedSpans.add(this.buildSpanKey(createRecord));
+      }
+    }
+  }
+  /** Check whether a span's create record has already been flushed to storage. */
+  spanExists(span) {
+    return this.#allCreatedSpans?.has(this.buildSpanKey({ traceId: span.traceId, spanId: span.id }));
+  }
+  /** Remove completed spans from tracking after their SPAN_ENDED updates are flushed. */
+  endFinishedSpans(args) {
+    if (this.#storageStrategy === "event-sourced" || this.#storageStrategy === "insert-only") {
+      return;
+    }
+    args.records.forEach((r) => {
+      this.#allCreatedSpans.delete(this.buildSpanKey(r));
+    });
+  }
+};
+
+// src/exporters/default.ts
+function resolveTracingStorageStrategy(config2, observabilityStorage, storageName, logger) {
+  const observabilityStrategy = observabilityStorage.observabilityStrategy;
   if (config2.strategy && config2.strategy !== "auto") {
-    const hints = observability.tracingStrategy;
-    if (hints.supported.includes(config2.strategy)) {
+    if (observabilityStrategy.supported.includes(config2.strategy)) {
       return config2.strategy;
     }
     logger.warn("User-specified tracing strategy not supported by storage adapter, falling back to auto-selection", {
       userStrategy: config2.strategy,
       storageAdapter: storageName,
-      supportedStrategies: hints.supported,
-      fallbackStrategy: hints.preferred
+      supportedStrategies: observabilityStrategy.supported,
+      fallbackStrategy: observabilityStrategy.preferred
     });
   }
-  return observability.tracingStrategy.preferred;
-}
-function getStringOrNull(value) {
-  return typeof value === "string" ? value : null;
-}
-function getObjectOrNull(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+  return observabilityStrategy.preferred;
 }
 var DefaultExporter = class extends BaseExporter {
   name = "mastra-default-observability-exporter";
-  #storage;
-  #observability;
   #config;
-  #resolvedStrategy;
-  buffer;
-  #flushTimer = null;
   #isInitializing = false;
   #initPromises = /* @__PURE__ */ new Set();
-  // Track all spans that have been created, persists across flushes
-  allCreatedSpans = /* @__PURE__ */ new Set();
+  #eventBuffer;
+  #storage;
+  #observabilityStorage;
+  #resolvedStrategy;
+  #flushTimer;
+  // Signals whose storage methods threw "not implemented" — skip on future flushes
+  #unsupportedSignals = /* @__PURE__ */ new Set();
   constructor(config2 = {}) {
     super(config2);
-    if (config2 === void 0) {
-      config2 = {};
-    }
     this.#config = {
       ...config2,
       maxBatchSize: config2.maxBatchSize ?? 1e3,
@@ -15307,19 +15462,8 @@ var DefaultExporter = class extends BaseExporter {
       retryDelayMs: config2.retryDelayMs ?? 500,
       strategy: config2.strategy ?? "auto"
     };
-    this.buffer = {
-      creates: [],
-      updates: [],
-      insertOnly: [],
-      seenSpans: /* @__PURE__ */ new Set(),
-      spanSequences: /* @__PURE__ */ new Map(),
-      completedSpans: /* @__PURE__ */ new Set(),
-      outOfOrderCount: 0,
-      totalSize: 0
-    };
-    this.#resolvedStrategy = "batch-with-updates";
+    this.#eventBuffer = new EventBuffer({ maxRetries: this.#config.maxRetries ?? 4 });
   }
-  #strategyInitialized = false;
   /**
    * Initialize the exporter (called after all dependencies are ready)
    */
@@ -15331,14 +15475,31 @@ var DefaultExporter = class extends BaseExporter {
         this.logger.warn("DefaultExporter disabled: Storage not available. Traces will not be persisted.");
         return;
       }
-      this.#observability = await this.#storage.getStore("observability");
-      if (!this.#observability) {
+      this.#observabilityStorage = await this.#storage.getStore("observability");
+      if (!this.#observabilityStorage) {
         this.logger.warn(
           "DefaultExporter disabled: Observability storage not available. Traces will not be persisted."
         );
         return;
       }
-      this.initializeStrategy(this.#observability, this.#storage.constructor.name);
+      if (!this.#resolvedStrategy) {
+        this.#resolvedStrategy = resolveTracingStorageStrategy(
+          this.#config,
+          this.#observabilityStorage,
+          this.#storage.constructor.name,
+          this.logger
+        );
+        this.logger.debug("tracing storage exporter initialized", {
+          strategy: this.#resolvedStrategy,
+          source: this.#config.strategy !== "auto" ? "user" : "auto",
+          storageAdapter: this.#storage.constructor.name,
+          maxBatchSize: this.#config.maxBatchSize,
+          maxBatchWaitMs: this.#config.maxBatchWaitMs
+        });
+      }
+      if (this.#resolvedStrategy) {
+        this.#eventBuffer.init({ strategy: this.#resolvedStrategy });
+      }
     } finally {
       this.#isInitializing = false;
       this.#initPromises.forEach((resolve) => {
@@ -15347,144 +15508,26 @@ var DefaultExporter = class extends BaseExporter {
       this.#initPromises.clear();
     }
   }
-  /**
-   * Initialize the resolved strategy once observability store is available
-   */
-  initializeStrategy(observability, storageName) {
-    if (this.#strategyInitialized) return;
-    this.#resolvedStrategy = resolveTracingStorageStrategy(this.#config, observability, storageName, this.logger);
-    this.#strategyInitialized = true;
-    this.logger.debug("tracing storage exporter initialized", {
-      strategy: this.#resolvedStrategy,
-      source: this.#config.strategy !== "auto" ? "user" : "auto",
-      storageAdapter: storageName,
-      maxBatchSize: this.#config.maxBatchSize,
-      maxBatchWaitMs: this.#config.maxBatchWaitMs
-    });
-  }
-  /**
-   * Builds a unique span key for tracking
-   */
-  buildSpanKey(traceId, spanId) {
-    return `${traceId}:${spanId}`;
-  }
-  /**
-   * Gets the next sequence number for a span
-   */
-  getNextSequence(spanKey) {
-    const current = this.buffer.spanSequences.get(spanKey) || 0;
-    const next = current + 1;
-    this.buffer.spanSequences.set(spanKey, next);
-    return next;
-  }
-  /**
-   * Handles out-of-order span updates by logging and skipping
-   */
-  handleOutOfOrderUpdate(event) {
-    this.logger.warn("Out-of-order span update detected - skipping event", {
-      spanId: event.exportedSpan.id,
-      traceId: event.exportedSpan.traceId,
-      spanName: event.exportedSpan.name,
-      eventType: event.type
-    });
-  }
-  /**
-   * Adds an event to the appropriate buffer based on strategy
-   */
-  addToBuffer(event) {
-    const spanKey = this.buildSpanKey(event.exportedSpan.traceId, event.exportedSpan.id);
-    if (this.buffer.totalSize === 0) {
-      this.buffer.firstEventTime = /* @__PURE__ */ new Date();
-    }
-    switch (event.type) {
-      case TracingEventType.SPAN_STARTED:
-        if (this.#resolvedStrategy === "batch-with-updates") {
-          const createRecord = this.buildCreateRecord(event.exportedSpan);
-          this.buffer.creates.push(createRecord);
-          this.buffer.seenSpans.add(spanKey);
-          this.allCreatedSpans.add(spanKey);
-        }
-        break;
-      case TracingEventType.SPAN_UPDATED:
-        if (this.#resolvedStrategy === "batch-with-updates") {
-          if (this.allCreatedSpans.has(spanKey)) {
-            this.buffer.updates.push({
-              traceId: event.exportedSpan.traceId,
-              spanId: event.exportedSpan.id,
-              updates: this.buildUpdateRecord(event.exportedSpan),
-              sequenceNumber: this.getNextSequence(spanKey)
-            });
-          } else {
-            this.handleOutOfOrderUpdate(event);
-            this.buffer.outOfOrderCount++;
-          }
-        }
-        break;
-      case TracingEventType.SPAN_ENDED:
-        if (this.#resolvedStrategy === "batch-with-updates") {
-          if (this.allCreatedSpans.has(spanKey)) {
-            this.buffer.updates.push({
-              traceId: event.exportedSpan.traceId,
-              spanId: event.exportedSpan.id,
-              updates: this.buildUpdateRecord(event.exportedSpan),
-              sequenceNumber: this.getNextSequence(spanKey)
-            });
-            this.buffer.completedSpans.add(spanKey);
-          } else if (event.exportedSpan.isEvent) {
-            const createRecord = this.buildCreateRecord(event.exportedSpan);
-            this.buffer.creates.push(createRecord);
-            this.buffer.seenSpans.add(spanKey);
-            this.allCreatedSpans.add(spanKey);
-            this.buffer.completedSpans.add(spanKey);
-          } else {
-            this.handleOutOfOrderUpdate(event);
-            this.buffer.outOfOrderCount++;
-          }
-        } else if (this.#resolvedStrategy === "insert-only") {
-          const createRecord = this.buildCreateRecord(event.exportedSpan);
-          this.buffer.insertOnly.push(createRecord);
-          this.buffer.completedSpans.add(spanKey);
-          this.allCreatedSpans.add(spanKey);
-        }
-        break;
-    }
-    this.buffer.totalSize = this.buffer.creates.length + this.buffer.updates.length + this.buffer.insertOnly.length;
-  }
   /**
    * Checks if buffer should be flushed based on size or time triggers
    */
   shouldFlush() {
-    if (this.buffer.totalSize >= this.#config.maxBufferSize) {
+    if (this.#resolvedStrategy === "realtime") {
       return true;
     }
-    if (this.buffer.totalSize >= this.#config.maxBatchSize) {
+    if (this.#eventBuffer.totalSize >= this.#config.maxBufferSize) {
       return true;
     }
-    if (this.buffer.firstEventTime && this.buffer.totalSize > 0) {
-      const elapsed = Date.now() - this.buffer.firstEventTime.getTime();
-      if (elapsed >= this.#config.maxBatchWaitMs) {
+    if (this.#eventBuffer.totalSize >= this.#config.maxBatchSize) {
+      return true;
+    }
+    if (this.#eventBuffer.totalSize > 0) {
+      if (this.#eventBuffer.elapsed >= this.#config.maxBatchWaitMs) {
         return true;
       }
     }
     return false;
   }
-  /**
-   * Resets the buffer after successful flush
-   */
-  resetBuffer(completedSpansToCleanup = /* @__PURE__ */ new Set()) {
-    this.buffer.creates = [];
-    this.buffer.updates = [];
-    this.buffer.insertOnly = [];
-    this.buffer.seenSpans.clear();
-    this.buffer.spanSequences.clear();
-    this.buffer.completedSpans.clear();
-    this.buffer.outOfOrderCount = 0;
-    this.buffer.firstEventTime = void 0;
-    this.buffer.totalSize = 0;
-    for (const spanKey of completedSpansToCleanup) {
-      this.allCreatedSpans.delete(spanKey);
-    }
-  }
   /**
    * Schedules a flush using setTimeout
    */
@@ -15501,276 +15544,185 @@ var DefaultExporter = class extends BaseExporter {
     }, this.#config.maxBatchWaitMs);
   }
   /**
-   * Serializes span attributes to storage record format
-   * Handles all Span types and their specific attributes
+   * Checks flush triggers and schedules/triggers flush as needed.
+   * Called after adding any event to the buffer.
+   * Returns the flush promise when flushing so callers can await it.
    */
-  serializeAttributes(span) {
-    if (!span.attributes) {
-      return null;
-    }
-    try {
-      return JSON.parse(
-        JSON.stringify(span.attributes, (_key, value) => {
-          if (value instanceof Date) {
-            return value.toISOString();
-          }
-          if (typeof value === "object" && value !== null) {
-            return value;
-          }
-          return value;
-        })
-      );
-    } catch (error48) {
-      this.logger.warn("Failed to serialize span attributes, storing as null", {
-        spanId: span.id,
-        spanType: span.type,
-        error: error48 instanceof Error ? error48.message : String(error48)
-      });
-      return null;
+  async handleBatchedFlush() {
+    if (this.shouldFlush()) {
+      await this.flushBuffer();
+    } else if (this.#eventBuffer.totalSize === 1) {
+      this.scheduleFlush();
     }
   }
-  buildCreateRecord(span) {
-    const metadata = span.metadata ?? {};
-    return {
-      traceId: span.traceId,
-      spanId: span.id,
-      parentSpanId: span.parentSpanId ?? null,
-      name: span.name,
-      // Entity identification - from span
-      entityType: span.entityType ?? null,
-      entityId: span.entityId ?? null,
-      entityName: span.entityName ?? null,
-      // Identity & Tenancy - extracted from metadata if present
-      userId: getStringOrNull(metadata.userId),
-      organizationId: getStringOrNull(metadata.organizationId),
-      resourceId: getStringOrNull(metadata.resourceId),
-      // Correlation IDs - extracted from metadata if present
-      runId: getStringOrNull(metadata.runId),
-      sessionId: getStringOrNull(metadata.sessionId),
-      threadId: getStringOrNull(metadata.threadId),
-      requestId: getStringOrNull(metadata.requestId),
-      // Deployment context - extracted from metadata if present
-      environment: getStringOrNull(metadata.environment),
-      source: getStringOrNull(metadata.source),
-      serviceName: getStringOrNull(metadata.serviceName),
-      scope: getObjectOrNull(metadata.scope),
-      // Span data
-      spanType: span.type,
-      attributes: this.serializeAttributes(span),
-      metadata: span.metadata ?? null,
-      // Keep all metadata including extracted fields
-      tags: span.tags ?? null,
-      links: null,
-      input: span.input ?? null,
-      output: span.output ?? null,
-      error: span.errorInfo ?? null,
-      requestContext: span.requestContext ?? null,
-      isEvent: span.isEvent,
-      // Timestamps
-      startedAt: span.startTime,
-      endedAt: span.endTime ?? null
-    };
-  }
-  buildUpdateRecord(span) {
-    return {
-      name: span.name,
-      scope: null,
-      attributes: this.serializeAttributes(span),
-      metadata: span.metadata ?? null,
-      links: null,
-      endedAt: span.endTime ?? null,
-      input: span.input,
-      output: span.output,
-      error: span.errorInfo ?? null,
-      requestContext: span.requestContext ?? null
-    };
-  }
   /**
-   * Handles realtime strategy - processes each event immediately
+   * 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 handleRealtimeEvent(event, observability) {
-    const span = event.exportedSpan;
-    const spanKey = this.buildSpanKey(span.traceId, span.id);
-    if (span.isEvent) {
-      if (event.type === TracingEventType.SPAN_ENDED) {
-        await observability.createSpan({ span: this.buildCreateRecord(event.exportedSpan) });
+  async flushCreates(signal, events, storageCall) {
+    if (this.#unsupportedSignals.has(signal) || events.length === 0) return;
+    try {
+      await storageCall(events);
+    } catch (error48) {
+      if (error48 instanceof MastraError && error48.domain === ErrorDomain.MASTRA_OBSERVABILITY && error48.id.endsWith("_NOT_IMPLEMENTED")) {
+        this.logger.warn(error48.message);
+        this.#unsupportedSignals.add(signal);
       } else {
-        this.logger.warn(`Tracing event type not implemented for event spans: ${event.type}`);
-      }
-    } else {
-      switch (event.type) {
-        case TracingEventType.SPAN_STARTED:
-          await observability.createSpan({ span: this.buildCreateRecord(event.exportedSpan) });
-          this.allCreatedSpans.add(spanKey);
-          break;
-        case TracingEventType.SPAN_UPDATED:
-          await observability.updateSpan({
-            traceId: span.traceId,
-            spanId: span.id,
-            updates: this.buildUpdateRecord(span)
-          });
-          break;
-        case TracingEventType.SPAN_ENDED:
-          await observability.updateSpan({
-            traceId: span.traceId,
-            spanId: span.id,
-            updates: this.buildUpdateRecord(span)
-          });
-          this.allCreatedSpans.delete(spanKey);
-          break;
-        default:
-          this.logger.warn(`Tracing event type not implemented for span spans: ${event.type}`);
+        this.#eventBuffer.reAddCreates(events);
       }
     }
   }
   /**
-   * Handles batch-with-updates strategy - buffers events and processes in batches
+   * Flush span update/end events, deferring any whose span hasn't been created yet.
+   * When `isEnd` is true, successfully flushed spans are removed from tracking.
    */
-  handleBatchWithUpdatesEvent(event) {
-    this.addToBuffer(event);
-    if (this.shouldFlush()) {
-      this.flushBuffer().catch((error48) => {
-        this.logger.error("Batch flush failed", {
-          error: error48 instanceof Error ? error48.message : String(error48)
+  async flushSpanUpdates(events, deferredUpdates, isEnd) {
+    if (this.#unsupportedSignals.has("tracing") || events.length === 0) return;
+    const partials = [];
+    for (const event of events) {
+      const span = event.exportedSpan;
+      if (this.#eventBuffer.spanExists(span)) {
+        partials.push({
+          traceId: span.traceId,
+          spanId: span.id,
+          updates: buildUpdateSpanRecord(span)
         });
-      });
-    } else if (this.buffer.totalSize === 1) {
-      this.scheduleFlush();
+      } else {
+        deferredUpdates.push(event);
+      }
     }
-  }
-  /**
-   * Handles insert-only strategy - only processes SPAN_ENDED events in batches
-   */
-  handleInsertOnlyEvent(event) {
-    if (event.type === TracingEventType.SPAN_ENDED) {
-      this.addToBuffer(event);
-      if (this.shouldFlush()) {
-        this.flushBuffer().catch((error48) => {
-          this.logger.error("Batch flush failed", {
-            error: error48 instanceof Error ? error48.message : String(error48)
-          });
-        });
-      } else if (this.buffer.totalSize === 1) {
-        this.scheduleFlush();
+    if (partials.length === 0) return;
+    try {
+      await this.#observabilityStorage.batchUpdateSpans({ records: partials });
+      if (isEnd) {
+        this.#eventBuffer.endFinishedSpans({ records: partials });
+      }
+    } catch (error48) {
+      if (error48 instanceof MastraError && error48.domain === ErrorDomain.MASTRA_OBSERVABILITY && error48.id.endsWith("_NOT_IMPLEMENTED")) {
+        this.logger.warn(error48.message);
+        this.#unsupportedSignals.add("tracing");
+      } else {
+        deferredUpdates.length = 0;
+        this.#eventBuffer.reAddUpdates(events);
       }
     }
   }
   /**
-   * Calculates retry delay using exponential backoff
-   */
-  calculateRetryDelay(attempt) {
-    return this.#config.retryDelayMs * Math.pow(2, attempt);
-  }
-  /**
-   * Flushes the current buffer to storage with retry logic (internal implementation)
+   * Flushes the current buffer to storage.
+   *
+   * Creates are flushed first, then their span keys are added to allCreatedSpans.
+   * Updates are checked against allCreatedSpans — those whose span hasn't been
+   * created yet are re-inserted into the live buffer for the next flush.
+   * Completed spans (SPAN_ENDED) are cleaned up from allCreatedSpans after success.
    */
   async flushBuffer() {
-    if (!this.#observability) {
-      this.logger.debug("Cannot flush traces. Observability storage is not initialized");
+    if (!this.#observabilityStorage) {
+      this.logger.debug("Cannot flush. Observability storage is not initialized");
+      return;
+    }
+    if (!this.#resolvedStrategy) {
+      this.logger.debug("Cannot flush. Observability strategy is not resolved");
       return;
     }
     if (this.#flushTimer) {
       clearTimeout(this.#flushTimer);
-      this.#flushTimer = null;
+      this.#flushTimer = void 0;
     }
-    if (this.buffer.totalSize === 0) {
+    if (this.#eventBuffer.totalSize === 0) {
       return;
     }
     const startTime = Date.now();
-    const flushReason = this.buffer.totalSize >= this.#config.maxBufferSize ? "overflow" : this.buffer.totalSize >= this.#config.maxBatchSize ? "size" : "time";
-    const bufferCopy = {
-      creates: [...this.buffer.creates],
-      updates: [...this.buffer.updates],
-      insertOnly: [...this.buffer.insertOnly],
-      seenSpans: new Set(this.buffer.seenSpans),
-      spanSequences: new Map(this.buffer.spanSequences),
-      completedSpans: new Set(this.buffer.completedSpans),
-      outOfOrderCount: this.buffer.outOfOrderCount,
-      firstEventTime: this.buffer.firstEventTime,
-      totalSize: this.buffer.totalSize
-    };
-    this.resetBuffer();
-    await this.flushWithRetries(this.#observability, bufferCopy, 0);
+    const batchSize = this.#eventBuffer.totalSize;
+    const creates = this.#eventBuffer.creates;
+    const updates = this.#eventBuffer.updates;
+    this.#eventBuffer.reset();
+    const createFeedbackEvents = [];
+    const createLogEvents = [];
+    const createMetricEvents = [];
+    const createScoreEvents = [];
+    const createSpanEvents = [];
+    const updateSpanEvents = [];
+    const endSpanEvents = [];
+    for (const createEvent of creates) {
+      switch (createEvent.type) {
+        case "feedback":
+          createFeedbackEvents.push(createEvent);
+          break;
+        case "log":
+          createLogEvents.push(createEvent);
+          break;
+        case "metric":
+          createMetricEvents.push(createEvent);
+          break;
+        case "score":
+          createScoreEvents.push(createEvent);
+          break;
+        default:
+          createSpanEvents.push(createEvent);
+          break;
+      }
+    }
+    for (const updateEvent of updates) {
+      switch (updateEvent.type) {
+        case TracingEventType.SPAN_UPDATED:
+          updateSpanEvents.push(updateEvent);
+          break;
+        case TracingEventType.SPAN_ENDED:
+          endSpanEvents.push(updateEvent);
+          break;
+      }
+    }
+    await Promise.all([
+      this.flushCreates(
+        "feedback",
+        createFeedbackEvents,
+        (events) => this.#observabilityStorage.batchCreateFeedback({ feedbacks: events.map((f) => buildFeedbackRecord(f)) })
+      ),
+      this.flushCreates(
+        "logs",
+        createLogEvents,
+        (events) => this.#observabilityStorage.batchCreateLogs({ logs: events.map((l) => buildLogRecord(l)) })
+      ),
+      this.flushCreates(
+        "metrics",
+        createMetricEvents,
+        (events) => this.#observabilityStorage.batchCreateMetrics({ metrics: events.map((m) => buildMetricRecord(m)) })
+      ),
+      this.flushCreates(
+        "scores",
+        createScoreEvents,
+        (events) => this.#observabilityStorage.batchCreateScores({ scores: events.map((s) => buildScoreRecord(s)) })
+      ),
+      this.flushCreates("tracing", createSpanEvents, async (events) => {
+        const records = events.map((t) => buildCreateSpanRecord(t.exportedSpan));
+        await this.#observabilityStorage.batchCreateSpans({ records });
+        this.#eventBuffer.addCreatedSpans({ records });
+      })
+    ]);
+    const deferredUpdates = [];
+    await this.flushSpanUpdates(updateSpanEvents, deferredUpdates, false);
+    await this.flushSpanUpdates(endSpanEvents, deferredUpdates, true);
+    if (deferredUpdates.length > 0) {
+      this.#eventBuffer.reAddUpdates(deferredUpdates);
+    }
     const elapsed = Date.now() - startTime;
     this.logger.debug("Batch flushed", {
       strategy: this.#resolvedStrategy,
-      batchSize: bufferCopy.totalSize,
-      flushReason,
+      batchSize,
       durationMs: elapsed,
-      outOfOrderCount: bufferCopy.outOfOrderCount > 0 ? bufferCopy.outOfOrderCount : void 0
+      deferredUpdates: deferredUpdates.length > 0 ? deferredUpdates.length : void 0
     });
-  }
-  /**
-   * Attempts to flush with exponential backoff retry logic
-   */
-  async flushWithRetries(observability, buffer, attempt) {
-    try {
-      if (this.#resolvedStrategy === "batch-with-updates") {
-        if (buffer.creates.length > 0) {
-          await observability.batchCreateSpans({ records: buffer.creates });
-        }
-        if (buffer.updates.length > 0) {
-          const sortedUpdates = buffer.updates.sort((a, b) => {
-            const spanCompare = this.buildSpanKey(a.traceId, a.spanId).localeCompare(
-              this.buildSpanKey(b.traceId, b.spanId)
-            );
-            if (spanCompare !== 0) return spanCompare;
-            return a.sequenceNumber - b.sequenceNumber;
-          });
-          await observability.batchUpdateSpans({ records: sortedUpdates });
-        }
-      } else if (this.#resolvedStrategy === "insert-only") {
-        if (buffer.insertOnly.length > 0) {
-          await observability.batchCreateSpans({ records: buffer.insertOnly });
-        }
-      }
-      for (const spanKey of buffer.completedSpans) {
-        this.allCreatedSpans.delete(spanKey);
-      }
-    } catch (error48) {
-      if (attempt < this.#config.maxRetries) {
-        const retryDelay = this.calculateRetryDelay(attempt);
-        this.logger.warn("Batch flush failed, retrying", {
-          attempt: attempt + 1,
-          maxRetries: this.#config.maxRetries,
-          nextRetryInMs: retryDelay,
-          error: error48 instanceof Error ? error48.message : String(error48)
-        });
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        return this.flushWithRetries(observability, buffer, attempt + 1);
-      } else {
-        this.logger.error("Batch flush failed after all retries, dropping batch", {
-          finalAttempt: attempt + 1,
-          maxRetries: this.#config.maxRetries,
-          droppedBatchSize: buffer.totalSize,
-          error: error48 instanceof Error ? error48.message : String(error48)
-        });
-        for (const spanKey of buffer.completedSpans) {
-          this.allCreatedSpans.delete(spanKey);
-        }
-      }
-    }
+    return;
   }
   async _exportTracingEvent(event) {
     await this.waitForInit();
-    if (!this.#observability) {
+    if (!this.#observabilityStorage) {
       this.logger.debug("Cannot store traces. Observability storage is not initialized");
       return;
     }
-    if (!this.#strategyInitialized) {
-      this.initializeStrategy(this.#observability, this.#storage?.constructor.name ?? "Unknown");
-    }
-    switch (this.#resolvedStrategy) {
-      case "realtime":
-        await this.handleRealtimeEvent(event, this.#observability);
-        break;
-      case "batch-with-updates":
-        this.handleBatchWithUpdatesEvent(event);
-        break;
-      case "insert-only":
-        this.handleInsertOnlyEvent(event);
-        break;
-    }
+    this.#eventBuffer.addEvent(event);
+    await this.handleBatchedFlush();
   }
   /**
    * Resolves when an ongoing init call is finished
@@ -15783,15 +15735,51 @@ var DefaultExporter = class extends BaseExporter {
       this.#initPromises.add(resolve);
     });
   }
+  /**
+   * Handle metric events — buffer for batch flush.
+   */
+  async onMetricEvent(event) {
+    await this.waitForInit();
+    if (!this.#observabilityStorage) return;
+    this.#eventBuffer.addEvent(event);
+    await this.handleBatchedFlush();
+  }
+  /**
+   * Handle log events — buffer for batch flush.
+   */
+  async onLogEvent(event) {
+    await this.waitForInit();
+    if (!this.#observabilityStorage) return;
+    this.#eventBuffer.addEvent(event);
+    await this.handleBatchedFlush();
+  }
+  /**
+   * Handle score events — buffer for batch flush.
+   */
+  async onScoreEvent(event) {
+    await this.waitForInit();
+    if (!this.#observabilityStorage) return;
+    this.#eventBuffer.addEvent(event);
+    await this.handleBatchedFlush();
+  }
+  /**
+   * Handle feedback events — buffer for batch flush.
+   */
+  async onFeedbackEvent(event) {
+    await this.waitForInit();
+    if (!this.#observabilityStorage) return;
+    this.#eventBuffer.addEvent(event);
+    await this.handleBatchedFlush();
+  }
   /**
    * Force flush any buffered spans without shutting down the exporter.
    * This is useful in serverless environments where you need to ensure spans
    * are exported before the runtime instance is terminated.
    */
   async flush() {
-    if (this.buffer.totalSize > 0) {
+    if (this.#eventBuffer.totalSize > 0) {
       this.logger.debug("Flushing buffered events", {
-        bufferedEvents: this.buffer.totalSize
+        bufferedEvents: this.#eventBuffer.totalSize
       });
       await this.flushBuffer();
     }
@@ -15799,7 +15787,7 @@ var DefaultExporter = class extends BaseExporter {
   async shutdown() {
     if (this.#flushTimer) {
       clearTimeout(this.#flushTimer);
-      this.#flushTimer = null;
+      this.#flushTimer = void 0;
     }
     await this.flush();
     this.logger.info("DefaultExporter shutdown complete");
@@ -15915,7 +15903,7 @@ var TestExporter = class extends BaseExporter {
     if (this.#config.storeLogs) {
       const metric = event.metric;
       const labelsStr = Object.entries(metric.labels).map(([k, v]) => `${k}=${v}`).join(", ");
-      const logMessage = `[TestExporter] metric.${metric.metricType}: ${metric.name}=${metric.value}${labelsStr ? ` {${labelsStr}}` : ""}`;
+      const logMessage = `[TestExporter] metric: ${metric.name}=${metric.value}${labelsStr ? ` {${labelsStr}}` : ""}`;
       this.#debugLogs.push(logMessage);
     }
     this.#metricEvents.push(event);
@@ -15927,7 +15915,7 @@ var TestExporter = class extends BaseExporter {
     this.#trackEvent("score");
     if (this.#config.storeLogs) {
       const score = event.score;
-      const logMessage = `[TestExporter] score: ${score.scorerName}=${score.score} (trace: ${score.traceId.slice(-8)}${score.spanId ? `, span: ${score.spanId.slice(-8)}` : ""})`;
+      const logMessage = `[TestExporter] score: ${score.scorerId}=${score.score} (trace: ${score.traceId.slice(-8)}${score.spanId ? `, span: ${score.spanId.slice(-8)}` : ""})`;
       this.#debugLogs.push(logMessage);
     }
     this.#scoreEvents.push(event);
@@ -16145,10 +16133,12 @@ var TestExporter = class extends BaseExporter {
     return this.#metricEvents.filter((e) => e.metric.name === name).map((e) => e.metric);
   }
   /**
-   * Get metrics filtered by type
+   * @deprecated MetricType is no longer stored. Use getMetricsByName() instead.
    */
-  getMetricsByType(metricType) {
-    return this.#metricEvents.filter((e) => e.metric.metricType === metricType).map((e) => e.metric);
+  getMetricsByType(_metricType) {
+    throw new Error(
+      "getMetricsByType() has been removed: metricType is no longer stored. Use getMetricsByName(metricName) instead to filter metrics by name."
+    );
   }
   // ============================================================================
   // Score Query Methods
@@ -16166,10 +16156,10 @@ var TestExporter = class extends BaseExporter {
     return this.#scoreEvents.map((e) => e.score);
   }
   /**
-   * Get scores filtered by scorer name
+   * Get scores filtered by scorer id
    */
-  getScoresByScorer(scorerName) {
-    return this.#scoreEvents.filter((e) => e.score.scorerName === scorerName).map((e) => e.score);
+  getScoresByScorer(scorerId) {
+    return this.#scoreEvents.filter((e) => e.score.scorerId === scorerId).map((e) => e.score);
   }
   /**
    * Get scores for a specific trace
@@ -16231,17 +16221,14 @@ var TestExporter = class extends BaseExporter {
       const level = event.log.level;
       logsByLevel[level] = (logsByLevel[level] || 0) + 1;
     }
-    const metricsByType = {};
     const metricsByName = {};
     for (const event of this.#metricEvents) {
-      const mType = event.metric.metricType;
-      metricsByType[mType] = (metricsByType[mType] || 0) + 1;
       const mName = event.metric.name;
       metricsByName[mName] = (metricsByName[mName] || 0) + 1;
     }
     const scoresByScorer = {};
     for (const event of this.#scoreEvents) {
-      const scorer = event.score.scorerName;
+      const scorer = event.score.scorerId;
       scoresByScorer[scorer] = (scoresByScorer[scorer] || 0) + 1;
     }
     const feedbackByType = {};
@@ -16266,7 +16253,6 @@ var TestExporter = class extends BaseExporter {
       totalLogs: this.#logEvents.length,
       logsByLevel,
       totalMetrics: this.#metricEvents.length,
-      metricsByType,
       metricsByName,
       totalScores: this.#scoreEvents.length,
       scoresByScorer,
@@ -16998,90 +16984,33 @@ var BaseObservabilityEventBus = class _BaseObservabilityEventBus extends MastraB
   }
 };
 var AutoExtractedMetrics = class {
-  /**
-   * @param observabilityBus - Bus used to emit derived MetricEvents.
-   * @param cardinalityFilter - Optional filter applied to metric labels before emission.
-   */
-  constructor(observabilityBus, cardinalityFilter) {
+  constructor(observabilityBus) {
     this.observabilityBus = observabilityBus;
-    this.cardinalityFilter = cardinalityFilter;
   }
   /**
-   * Route a tracing event to the appropriate span lifecycle handler.
-   * SPAN_STARTED increments a started counter; SPAN_ENDED emits ended counter,
-   * duration histogram, and (for model spans) token counters.
+   * Route a tracing event to the appropriate handler.
+   * SPAN_ENDED emits duration and token metrics (for model spans).
    */
   processTracingEvent(event) {
-    switch (event.type) {
-      case TracingEventType.SPAN_STARTED:
-        this.onSpanStarted(event.exportedSpan);
-        break;
-      case TracingEventType.SPAN_ENDED:
-        this.onSpanEnded(event.exportedSpan);
-        break;
-    }
-  }
-  /** Emit a `mastra_scores_total` counter for a score event. */
-  processScoreEvent(event) {
-    const labels = {
-      scorer: event.score.scorerName
-    };
-    if (event.score.metadata?.entityType) {
-      labels.entity_type = String(event.score.metadata.entityType);
-    }
-    if (event.score.experimentId) {
-      labels.experiment = event.score.experimentId;
-    }
-    this.emit("mastra_scores_total", "counter", 1, labels);
-  }
-  /** Emit a `mastra_feedback_total` counter for a feedback event. */
-  processFeedbackEvent(event) {
-    const labels = {
-      feedback_type: event.feedback.feedbackType,
-      source: event.feedback.source
-    };
-    if (event.feedback.metadata?.entityType) {
-      labels.entity_type = String(event.feedback.metadata.entityType);
-    }
-    if (event.feedback.experimentId) {
-      labels.experiment = event.feedback.experimentId;
-    }
-    this.emit("mastra_feedback_total", "counter", 1, labels);
-  }
-  /** Emit a started counter (e.g. `mastra_agent_runs_started`) for the span type. */
-  onSpanStarted(span) {
-    const labels = this.extractLabels(span);
-    const metricName = this.getStartedMetricName(span);
-    if (metricName) {
-      this.emit(metricName, "counter", 1, labels);
+    if (event.type === TracingEventType.SPAN_ENDED) {
+      this.onSpanEnded(event.exportedSpan);
     }
   }
-  /** Emit ended counter, duration histogram, and token counters (for model spans). */
+  /** Emit duration and token metrics when a span ends. */
   onSpanEnded(span) {
     const labels = this.extractLabels(span);
-    const endedMetricName = this.getEndedMetricName(span);
-    if (endedMetricName) {
-      const endedLabels = { ...labels };
-      if (span.errorInfo) {
-        endedLabels.status = "error";
-      } else {
-        endedLabels.status = "ok";
-      }
-      this.emit(endedMetricName, "counter", 1, endedLabels);
-    }
     const durationMetricName = this.getDurationMetricName(span);
     if (durationMetricName && span.startTime && span.endTime) {
-      const durationMs = Math.max(0, span.endTime.getTime() - span.startTime.getTime());
+      const durationMs = span.endTime.getTime() - span.startTime.getTime();
       const durationLabels = { ...labels };
-      if (span.errorInfo) {
-        durationLabels.status = "error";
-      } else {
-        durationLabels.status = "ok";
-      }
-      this.emit(durationMetricName, "histogram", durationMs, durationLabels);
+      durationLabels.status = span.errorInfo ? "error" : "ok";
+      this.observabilityBus.emitMetric(durationMetricName, durationMs, durationLabels);
     }
     if (span.type === SpanType.MODEL_GENERATION) {
-      this.extractTokenMetrics(span, labels);
+      const attrs = span.attributes;
+      if (attrs?.usage) {
+        this.extractTokenMetrics(attrs.usage, labels);
+      }
     }
   }
   /** Build base metric labels from a span's entity and model attributes. */
@@ -17092,65 +17021,34 @@ var AutoExtractedMetrics = class {
     if (entityName) labels.entity_name = entityName;
     if (span.type === SpanType.MODEL_GENERATION) {
       const attrs = span.attributes;
-      if (attrs?.model) labels.model = String(attrs.model);
-      if (attrs?.provider) labels.provider = String(attrs.provider);
+      if (attrs?.model) labels.model = attrs.model;
+      if (attrs?.provider) labels.provider = attrs.provider;
     }
     return labels;
   }
-  /** Emit token usage counters from a MODEL_GENERATION span's `usage` attributes. Negative and non-finite values are skipped. */
-  extractTokenMetrics(span, labels) {
-    const attrs = span.attributes;
-    const usage = attrs?.usage;
-    if (!usage) return;
-    const inputTokens = Number(usage.inputTokens);
-    if (Number.isFinite(inputTokens) && inputTokens >= 0) {
-      this.emit("mastra_model_input_tokens", "counter", inputTokens, labels);
-    }
-    const outputTokens = Number(usage.outputTokens);
-    if (Number.isFinite(outputTokens) && outputTokens >= 0) {
-      this.emit("mastra_model_output_tokens", "counter", outputTokens, labels);
-    }
-    const inputDetails = usage.inputDetails;
-    const cacheRead = Number(inputDetails?.cacheRead);
-    if (Number.isFinite(cacheRead) && cacheRead >= 0) {
-      this.emit("mastra_model_cache_read_tokens", "counter", cacheRead, labels);
-    }
-    const cacheWrite = Number(inputDetails?.cacheWrite);
-    if (Number.isFinite(cacheWrite) && cacheWrite >= 0) {
-      this.emit("mastra_model_cache_write_tokens", "counter", cacheWrite, labels);
-    }
-  }
-  /** Map a span type to its `*_started` counter metric name, or `null` for unsupported types. */
-  getStartedMetricName(span) {
-    switch (span.type) {
-      case SpanType.AGENT_RUN:
-        return "mastra_agent_runs_started";
-      case SpanType.TOOL_CALL:
-        return "mastra_tool_calls_started";
-      case SpanType.WORKFLOW_RUN:
-        return "mastra_workflow_runs_started";
-      case SpanType.MODEL_GENERATION:
-        return "mastra_model_requests_started";
-      default:
-        return null;
-    }
-  }
-  /** Map a span type to its `*_ended` counter metric name, or `null` for unsupported types. */
-  getEndedMetricName(span) {
-    switch (span.type) {
-      case SpanType.AGENT_RUN:
-        return "mastra_agent_runs_ended";
-      case SpanType.TOOL_CALL:
-        return "mastra_tool_calls_ended";
-      case SpanType.WORKFLOW_RUN:
-        return "mastra_workflow_runs_ended";
-      case SpanType.MODEL_GENERATION:
-        return "mastra_model_requests_ended";
-      default:
-        return null;
-    }
-  }
-  /** Map a span type to its `*_duration_ms` histogram metric name, or `null` for unsupported types. */
+  /** Emit token usage metrics from UsageStats. */
+  extractTokenMetrics(usage, labels) {
+    const emit = (name, value) => this.observabilityBus.emitMetric(name, value, labels);
+    const emitNonZero = (name, value) => {
+      if (value > 0) emit(name, value);
+    };
+    emit("mastra_model_total_input_tokens", usage.inputTokens ?? 0);
+    emit("mastra_model_total_output_tokens", usage.outputTokens ?? 0);
+    if (usage.inputDetails) {
+      emitNonZero("mastra_model_input_text_tokens", usage.inputDetails.text ?? 0);
+      emitNonZero("mastra_model_input_cache_read_tokens", usage.inputDetails.cacheRead ?? 0);
+      emitNonZero("mastra_model_input_cache_write_tokens", usage.inputDetails.cacheWrite ?? 0);
+      emitNonZero("mastra_model_input_audio_tokens", usage.inputDetails.audio ?? 0);
+      emitNonZero("mastra_model_input_image_tokens", usage.inputDetails.image ?? 0);
+    }
+    if (usage.outputDetails) {
+      emitNonZero("mastra_model_output_text_tokens", usage.outputDetails.text ?? 0);
+      emitNonZero("mastra_model_output_reasoning_tokens", usage.outputDetails.reasoning ?? 0);
+      emitNonZero("mastra_model_output_audio_tokens", usage.outputDetails.audio ?? 0);
+      emitNonZero("mastra_model_output_image_tokens", usage.outputDetails.image ?? 0);
+    }
+  }
+  /** Map a span type to its `*_duration_ms` metric name, or `null` for unsupported types. */
   getDurationMetricName(span) {
     switch (span.type) {
       case SpanType.AGENT_RUN:
@@ -17165,18 +17063,38 @@ var AutoExtractedMetrics = class {
         return null;
     }
   }
-  /** Build an ExportedMetric, apply cardinality filtering, and emit it through the bus. */
-  emit(name, metricType, value, labels) {
-    const filteredLabels = this.cardinalityFilter ? this.cardinalityFilter.filterLabels(labels) : labels;
-    const exportedMetric = {
-      timestamp: /* @__PURE__ */ new Date(),
-      name,
-      metricType,
-      value,
-      labels: filteredLabels
-    };
-    const event = { type: "metric", metric: exportedMetric };
-    this.observabilityBus.emit(event);
+};
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var CardinalityFilter = class {
+  blockedLabels;
+  blockUUIDs;
+  /**
+   * @param config - Optional configuration. When omitted, uses
+   *   {@link DEFAULT_BLOCKED_LABELS} and blocks UUID-valued labels.
+   */
+  constructor(config2) {
+    const blocked = config2?.blockedLabels ?? [...DEFAULT_BLOCKED_LABELS];
+    this.blockedLabels = new Set(blocked.map((l) => l.toLowerCase()));
+    this.blockUUIDs = config2?.blockUUIDs ?? true;
+  }
+  /**
+   * Return a copy of `labels` with blocked keys and UUID values removed.
+   *
+   * @param labels - Raw metric labels to filter.
+   * @returns A new object containing only the allowed labels.
+   */
+  filterLabels(labels) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(labels)) {
+      if (this.blockedLabels.has(key.toLowerCase())) {
+        continue;
+      }
+      if (this.blockUUIDs && UUID_REGEX.test(value)) {
+        continue;
+      }
+      filtered[key] = value;
+    }
+    return filtered;
   }
 };
 function routeToHandler(handler, event, logger) {
@@ -17230,25 +17148,32 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
   exporters = [];
   bridge;
   autoExtractor;
+  cardinalityFilter;
   /** In-flight handler promises from routeToHandler. Self-cleaning via .finally(). */
   pendingHandlers = /* @__PURE__ */ new Set();
-  constructor() {
+  constructor(config2) {
     super({ name: "ObservabilityBus" });
+    this.cardinalityFilter = config2?.cardinalityFilter ?? new CardinalityFilter();
+    if (config2?.autoExtractMetrics !== false) {
+      this.autoExtractor = new AutoExtractedMetrics(this);
+    }
   }
   /**
-   * Enable auto-extraction of metrics from tracing, score, and feedback events.
-   * When enabled, span lifecycle events automatically generate counter/histogram
-   * metrics (e.g., mastra_agent_runs_started, mastra_model_duration_ms).
-   *
-   * No-ops if auto-extraction is already enabled.
-   *
-   * @param cardinalityFilter - Optional filter applied to auto-extracted metric labels.
+   * Emit a metric event with validation and cardinality filtering.
+   * Non-finite or negative values are silently dropped.
+   * This is the single entry point for all metric emission (auto-extracted and user-defined).
    */
-  enableAutoExtractedMetrics(cardinalityFilter) {
-    if (this.autoExtractor) {
-      return;
-    }
-    this.autoExtractor = new AutoExtractedMetrics(this, cardinalityFilter);
+  emitMetric(name, value, labels) {
+    if (!Number.isFinite(value) || value < 0) return;
+    const filteredLabels = this.cardinalityFilter.filterLabels(labels);
+    const exportedMetric = {
+      timestamp: /* @__PURE__ */ new Date(),
+      name,
+      value,
+      labels: filteredLabels
+    };
+    const event = { type: "metric", metric: exportedMetric };
+    this.emit(event);
   }
   /**
    * Register an exporter to receive routed events.
@@ -17327,15 +17252,9 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
     if (this.bridge) {
       this.trackPromise(routeToHandler(this.bridge, event, this.logger));
     }
-    if (this.autoExtractor) {
+    if (this.autoExtractor && isTracingEvent(event)) {
       try {
-        if (isTracingEvent(event)) {
-          this.autoExtractor.processTracingEvent(event);
-        } else if (event.type === "score") {
-          this.autoExtractor.processScoreEvent(event);
-        } else if (event.type === "feedback") {
-          this.autoExtractor.processFeedbackEvent(event);
-        }
+        this.autoExtractor.processTracingEvent(event);
       } catch (err) {
         this.logger.error("[ObservabilityBus] Auto-extraction error:", err);
       }
@@ -17462,104 +17381,45 @@ var LoggerContextImpl = class {
 
 // src/context/metrics.ts
 var MetricsContextImpl = class {
-  config;
+  baseLabels;
+  observabilityBus;
   /**
    * Create a metrics context. Base labels are defensively copied so
    * mutations after construction do not affect emitted metrics.
    */
   constructor(config2) {
-    this.config = {
-      ...config2,
-      labels: config2.labels ? { ...config2.labels } : void 0
-    };
+    this.baseLabels = config2.labels ? { ...config2.labels } : {};
+    this.observabilityBus = config2.observabilityBus;
   }
-  /**
-   * Create a counter instrument. Call `.add(value)` to increment.
-   *
-   * @param name - Metric name (e.g. `mastra_custom_requests_total`).
-   */
+  /** Emit a metric observation. */
+  emit(name, value, labels) {
+    const allLabels = { ...this.baseLabels, ...labels };
+    this.observabilityBus.emitMetric(name, value, allLabels);
+  }
+  /** @deprecated Use `emit()` instead. */
   counter(name) {
     return {
       add: (value, additionalLabels) => {
-        this.emit(name, "counter", value, additionalLabels);
+        this.emit(name, value, additionalLabels);
       }
     };
   }
-  /**
-   * Create a gauge instrument. Call `.set(value)` to record a point-in-time value.
-   *
-   * @param name - Metric name (e.g. `mastra_queue_depth`).
-   */
+  /** @deprecated Use `emit()` instead. */
   gauge(name) {
     return {
       set: (value, additionalLabels) => {
-        this.emit(name, "gauge", value, additionalLabels);
+        this.emit(name, value, additionalLabels);
       }
     };
   }
-  /**
-   * Create a histogram instrument. Call `.record(value)` to observe a measurement.
-   *
-   * @param name - Metric name (e.g. `mastra_request_duration_ms`).
-   */
+  /** @deprecated Use `emit()` instead. */
   histogram(name) {
     return {
       record: (value, additionalLabels) => {
-        this.emit(name, "histogram", value, additionalLabels);
+        this.emit(name, value, additionalLabels);
       }
     };
   }
-  /** Merge base + additional labels, apply cardinality filtering, and emit a MetricEvent. Non-finite values are silently dropped. */
-  emit(name, metricType, value, additionalLabels) {
-    if (!Number.isFinite(value)) return;
-    const allLabels = {
-      ...this.config.labels,
-      ...additionalLabels
-    };
-    const filteredLabels = this.config.cardinalityFilter.filterLabels(allLabels);
-    const exportedMetric = {
-      timestamp: /* @__PURE__ */ new Date(),
-      name,
-      metricType,
-      value,
-      labels: filteredLabels
-    };
-    const event = { type: "metric", metric: exportedMetric };
-    this.config.observabilityBus.emit(event);
-  }
-};
-var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var CardinalityFilter = class {
-  blockedLabels;
-  blockUUIDs;
-  /**
-   * @param config - Optional configuration. When omitted, uses
-   *   {@link DEFAULT_BLOCKED_LABELS} and blocks UUID-valued labels.
-   */
-  constructor(config2) {
-    const blocked = config2?.blockedLabels ?? [...DEFAULT_BLOCKED_LABELS];
-    this.blockedLabels = new Set(blocked.map((l) => l.toLowerCase()));
-    this.blockUUIDs = config2?.blockUUIDs ?? true;
-  }
-  /**
-   * Return a copy of `labels` with blocked keys and UUID values removed.
-   *
-   * @param labels - Raw metric labels to filter.
-   * @returns A new object containing only the allowed labels.
-   */
-  filterLabels(labels) {
-    const filtered = {};
-    for (const [key, value] of Object.entries(labels)) {
-      if (this.blockedLabels.has(key.toLowerCase())) {
-        continue;
-      }
-      if (this.blockUUIDs && UUID_REGEX.test(value)) {
-        continue;
-      }
-      filtered[key] = value;
-    }
-    return filtered;
-  }
 };
 
 // src/usage.ts
@@ -18614,15 +18474,16 @@ var BaseObservabilityInstance = class extends MastraBase {
       requestContextKeys: config2.requestContextKeys ?? [],
       serializationOptions: config2.serializationOptions
     };
-    this.cardinalityFilter = new CardinalityFilter();
-    this.observabilityBus = new ObservabilityBus();
+    this.cardinalityFilter = new CardinalityFilter(config2.cardinality);
+    this.observabilityBus = new ObservabilityBus({
+      cardinalityFilter: this.cardinalityFilter
+    });
     for (const exporter of this.exporters) {
       this.observabilityBus.registerExporter(exporter);
     }
     if (this.config.bridge) {
       this.observabilityBus.registerBridge(this.config.bridge);
     }
-    this.observabilityBus.enableAutoExtractedMetrics(this.cardinalityFilter);
     if (this.config.bridge?.init) {
       this.config.bridge.init({ config: this.config });
     }
@@ -18866,8 +18727,7 @@ var BaseObservabilityInstance = class extends MastraBase {
     if (this.config.serviceName) labels.service_name = this.config.serviceName;
     return new MetricsContextImpl({
       labels: Object.keys(labels).length > 0 ? labels : void 0,
-      observabilityBus: this.observabilityBus,
-      cardinalityFilter: this.cardinalityFilter
+      observabilityBus: this.observabilityBus
     });
   }
   /**
@@ -19014,6 +18874,7 @@ var BaseObservabilityInstance = class extends MastraBase {
   // ============================================================================
   // Event-driven Export Methods
   // ============================================================================
+  /** Process a span through output processors and export it, returning undefined if filtered out. */
   getSpanForExport(span) {
     if (!span.isValid) return void 0;
     if (span.isInternal && !this.config.includeInternalSpans) return void 0;
@@ -19061,7 +18922,7 @@ var BaseObservabilityInstance = class extends MastraBase {
    *
    * The bus routes the event to each registered exporter's and bridge's
    * onTracingEvent handler and triggers auto-extracted metrics (e.g.,
-   * mastra_agent_runs_started, mastra_model_duration_ms).
+   * mastra_agent_duration_ms, mastra_model_duration_ms).
    */
   emitTracingEvent(event) {
     this.observabilityBus.emit(event);
@@ -19399,7 +19260,9 @@ var Observability = class extends MastraBase {
     }
     const validationResult = observabilityRegistryConfigSchema.safeParse(config2);
     if (!validationResult.success) {
-      const errorMessages = validationResult.error.issues.map((err) => `${err.path.join(".") || "config"}: ${err.message}`).join("; ");
+      const errorMessages = validationResult.error.issues.map(
+        (err) => `${err.path.join(".") || "config"}: ${err.message}`
+      ).join("; ");
       throw new MastraError({
         id: "OBSERVABILITY_INVALID_CONFIG",
         text: `Invalid observability configuration: ${errorMessages}`,
@@ -19415,7 +19278,9 @@ var Observability = class extends MastraBase {
         if (!isInstance(configValue)) {
           const configValidation = observabilityConfigValueSchema.safeParse(configValue);
           if (!configValidation.success) {
-            const errorMessages = configValidation.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ");
+            const errorMessages = configValidation.error.issues.map(
+              (err) => `${err.path.join(".")}: ${err.message}`
+            ).join("; ");
             throw new MastraError({
               id: "OBSERVABILITY_INVALID_INSTANCE_CONFIG",
               text: `Invalid configuration for observability instance '${name}': ${errorMessages}`,
@@ -19455,6 +19320,7 @@ var Observability = class extends MastraBase {
       this.#registry.setSelector(config2.configSelector);
     }
   }
+  /** Initialize all exporter instances with the Mastra context (storage, config, etc.). */
   setMastraContext(options) {
     const instances = this.listInstances();
     const { mastra } = options;
@@ -19475,42 +19341,50 @@ var Observability = class extends MastraBase {
       });
     });
   }
+  /** Propagate a logger to this instance and all registered observability instances. */
   setLogger(options) {
     super.__setLogger(options.logger);
     this.listInstances().forEach((instance) => {
       instance.__setLogger(options.logger);
     });
   }
+  /** Get the observability instance chosen by the config selector for the given options. */
   getSelectedInstance(options) {
     return this.#registry.getSelected(options);
   }
-  /**
-   * Registry management methods
-   */
+  /** Register a named observability instance, optionally marking it as default. */
   registerInstance(name, instance, isDefault = false) {
     this.#registry.register(name, instance, isDefault);
   }
+  /** Get a registered instance by name. */
   getInstance(name) {
     return this.#registry.get(name);
   }
+  /** Get the default observability instance. */
   getDefaultInstance() {
     return this.#registry.getDefault();
   }
+  /** List all registered observability instances. */
   listInstances() {
     return this.#registry.list();
   }
+  /** Unregister an instance by name. Returns true if it was found and removed. */
   unregisterInstance(name) {
     return this.#registry.unregister(name);
   }
+  /** Check whether an instance with the given name is registered. */
   hasInstance(name) {
     return !!this.#registry.get(name);
   }
+  /** Set the config selector used to choose an instance at runtime. */
   setConfigSelector(selector) {
     this.#registry.setSelector(selector);
   }
+  /** Remove all registered instances and reset the registry. */
   clear() {
     this.#registry.clear();
   }
+  /** Shut down all registered instances, flushing any pending data. */
   async shutdown() {
     await this.#registry.shutdown();
   }