@mastra/observability 1.12.0-alpha.2 → 1.12.0-alpha.3

package/dist/index.cjs

@@ -16217,6 +16217,852 @@ var DefaultExporter = class extends BaseExporter {
     this.logger.info("DefaultExporter shutdown complete");
   }
 };
+var SIGNAL_PUBLISH_SUFFIXES2 = {
+  traces: "/spans/publish",
+  logs: "/logs/publish",
+  metrics: "/metrics/publish",
+  scores: "/scores/publish",
+  feedback: "/feedback/publish"
+};
+var DEFAULT_PLATFORM_SPAN_FILTER = (span) => span.type !== observability.SpanType.MODEL_CHUNK;
+var SIGNAL_PUBLISH_SEGMENTS2 = {
+  traces: "spans",
+  logs: "logs",
+  metrics: "metrics",
+  scores: "scores",
+  feedback: "feedback"
+};
+function trimTrailingSlashes2(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+function createInvalidEndpointError2(endpoint, text, cause) {
+  return new error$1.MastraError(
+    {
+      id: `MASTRA_PLATFORM_EXPORTER_INVALID_ENDPOINT`,
+      text,
+      domain: error$1.ErrorDomain.MASTRA_OBSERVABILITY,
+      category: error$1.ErrorCategory.USER,
+      details: {
+        endpoint
+      }
+    },
+    cause
+  );
+}
+var VALID_PROJECT_ID2 = /^[a-zA-Z0-9_-]+$/;
+function createInvalidProjectIdError2(projectId) {
+  return new error$1.MastraError({
+    id: `MASTRA_PLATFORM_EXPORTER_INVALID_PROJECT_ID`,
+    text: "MastraPlatformExporter projectId must only contain letters, numbers, hyphens, and underscores.",
+    domain: error$1.ErrorDomain.MASTRA_OBSERVABILITY,
+    category: error$1.ErrorCategory.USER,
+    details: {
+      projectId
+    }
+  });
+}
+function resolveBaseEndpoint2(baseEndpoint) {
+  const normalizedEndpoint = trimTrailingSlashes2(baseEndpoint);
+  const invalidText = 'MastraPlatformExporter endpoint must be a base origin like "https://collector.example.com" with no path, search, or hash.';
+  try {
+    const parsedEndpoint = new URL(normalizedEndpoint);
+    if (parsedEndpoint.pathname !== "/" || parsedEndpoint.search || parsedEndpoint.hash) {
+      throw createInvalidEndpointError2(baseEndpoint, invalidText);
+    }
+    return trimTrailingSlashes2(parsedEndpoint.origin);
+  } catch (error48) {
+    if (error48 instanceof error$1.MastraError) {
+      throw error48;
+    }
+    throw createInvalidEndpointError2(baseEndpoint, invalidText, error48);
+  }
+}
+function buildSignalPath2(signal, projectId) {
+  const signalSegment = SIGNAL_PUBLISH_SEGMENTS2[signal];
+  if (!projectId) {
+    return `/ai/${signalSegment}/publish`;
+  }
+  return `/projects/${projectId}/ai/${signalSegment}/publish`;
+}
+function buildSignalEndpoint2(baseEndpoint, signal, projectId) {
+  return `${baseEndpoint}${buildSignalPath2(signal, projectId)}`;
+}
+function resolveExplicitSignalEndpoint2(signal, endpoint, projectId) {
+  const normalizedEndpoint = trimTrailingSlashes2(endpoint);
+  const invalidText = `MastraPlatformExporter ${signal}Endpoint must be a base origin like "https://collector.example.com" or a full ${signal} publish URL ending in "${SIGNAL_PUBLISH_SUFFIXES2[signal]}".`;
+  try {
+    const parsedEndpoint = new URL(normalizedEndpoint);
+    if (parsedEndpoint.search || parsedEndpoint.hash) {
+      throw createInvalidEndpointError2(endpoint, invalidText);
+    }
+    const normalizedOrigin = trimTrailingSlashes2(parsedEndpoint.origin);
+    const normalizedPathname = trimTrailingSlashes2(parsedEndpoint.pathname);
+    if (!normalizedPathname || normalizedPathname === "/") {
+      return buildSignalEndpoint2(normalizedOrigin, signal, projectId);
+    }
+    if (normalizedPathname.endsWith(SIGNAL_PUBLISH_SUFFIXES2[signal])) {
+      return `${normalizedOrigin}${normalizedPathname}`;
+    }
+    throw createInvalidEndpointError2(endpoint, invalidText);
+  } catch (error48) {
+    if (error48 instanceof error$1.MastraError) {
+      throw error48;
+    }
+    throw createInvalidEndpointError2(endpoint, invalidText, error48);
+  }
+}
+function deriveSignalEndpointFromTracesEndpoint2(signal, tracesEndpoint) {
+  if (signal === "traces") {
+    return tracesEndpoint;
+  }
+  const normalizedTracesEndpoint = trimTrailingSlashes2(tracesEndpoint);
+  const invalidText = 'MastraPlatformExporter tracesEndpoint must be a base origin like "https://collector.example.com" or a full traces publish URL ending in "/spans/publish".';
+  try {
+    const parsedEndpoint = new URL(normalizedTracesEndpoint);
+    const normalizedOrigin = trimTrailingSlashes2(parsedEndpoint.origin);
+    const normalizedPathname = trimTrailingSlashes2(parsedEndpoint.pathname);
+    if (!normalizedPathname.endsWith(SIGNAL_PUBLISH_SUFFIXES2.traces)) {
+      throw createInvalidEndpointError2(tracesEndpoint, invalidText);
+    }
+    const basePath = normalizedPathname.slice(0, -SIGNAL_PUBLISH_SUFFIXES2.traces.length);
+    return `${normalizedOrigin}${basePath}${SIGNAL_PUBLISH_SUFFIXES2[signal]}`;
+  } catch (error48) {
+    if (error48 instanceof error$1.MastraError) {
+      throw error48;
+    }
+    throw createInvalidEndpointError2(tracesEndpoint, invalidText, error48);
+  }
+}
+var MastraPlatformExporter = class extends BaseExporter {
+  name = "mastra-platform-exporter";
+  platformConfig;
+  buffer;
+  flushTimer = null;
+  inFlightFlushes = /* @__PURE__ */ new Set();
+  constructor(config2 = {}) {
+    super(config2);
+    if (config2.projectId !== void 0 && !VALID_PROJECT_ID2.test(config2.projectId)) {
+      throw createInvalidProjectIdError2(config2.projectId);
+    }
+    const accessToken = config2.accessToken ?? process.env.MASTRA_CLOUD_ACCESS_TOKEN;
+    const envProjectId = process.env.MASTRA_PROJECT_ID === "" ? void 0 : process.env.MASTRA_PROJECT_ID;
+    const rawProjectId = config2.projectId ?? envProjectId;
+    if (rawProjectId !== void 0 && !VALID_PROJECT_ID2.test(rawProjectId)) {
+      throw createInvalidProjectIdError2(rawProjectId);
+    }
+    const projectId = rawProjectId;
+    if (!accessToken) {
+      this.setDisabled("MASTRA_CLOUD_ACCESS_TOKEN environment variable not set.", "debug");
+    }
+    const tracesEndpointOverride = config2.tracesEndpoint ?? process.env.MASTRA_CLOUD_TRACES_ENDPOINT;
+    let baseEndpoint;
+    let tracesEndpoint;
+    if (tracesEndpointOverride) {
+      tracesEndpoint = resolveExplicitSignalEndpoint2("traces", tracesEndpointOverride, projectId);
+    } else {
+      baseEndpoint = resolveBaseEndpoint2(config2.endpoint ?? "https://observability.mastra.ai");
+      tracesEndpoint = buildSignalEndpoint2(baseEndpoint, "traces", projectId);
+    }
+    const resolveConfiguredSignalEndpoint = (signal, explicitEndpoint) => {
+      if (explicitEndpoint) {
+        return resolveExplicitSignalEndpoint2(signal, explicitEndpoint, projectId);
+      }
+      if (tracesEndpointOverride) {
+        return deriveSignalEndpointFromTracesEndpoint2(signal, tracesEndpoint);
+      }
+      return buildSignalEndpoint2(baseEndpoint, signal, projectId);
+    };
+    this.platformConfig = {
+      logger: this.logger,
+      logLevel: config2.logLevel ?? logger.LogLevel.INFO,
+      maxBatchSize: config2.maxBatchSize ?? 1e3,
+      maxBatchWaitMs: config2.maxBatchWaitMs ?? 5e3,
+      maxRetries: config2.maxRetries ?? 3,
+      accessToken: accessToken || "",
+      tracesEndpoint,
+      logsEndpoint: resolveConfiguredSignalEndpoint("logs", config2.logsEndpoint),
+      metricsEndpoint: resolveConfiguredSignalEndpoint("metrics", config2.metricsEndpoint),
+      scoresEndpoint: resolveConfiguredSignalEndpoint("scores", config2.scoresEndpoint),
+      feedbackEndpoint: resolveConfiguredSignalEndpoint("feedback", config2.feedbackEndpoint)
+    };
+    this.buffer = {
+      spans: [],
+      logs: [],
+      metrics: [],
+      scores: [],
+      feedback: [],
+      totalSize: 0
+    };
+  }
+  async _exportTracingEvent(event) {
+    if (event.type !== observability.TracingEventType.SPAN_ENDED) {
+      return;
+    }
+    if (!DEFAULT_PLATFORM_SPAN_FILTER(event.exportedSpan)) {
+      return;
+    }
+    this.addToBuffer(event);
+    await this.handleBufferedEvent();
+  }
+  async onLogEvent(event) {
+    if (this.isDisabled) {
+      return;
+    }
+    this.addLogToBuffer(event);
+    await this.handleBufferedEvent();
+  }
+  async onMetricEvent(event) {
+    if (this.isDisabled) {
+      return;
+    }
+    this.addMetricToBuffer(event);
+    await this.handleBufferedEvent();
+  }
+  async onScoreEvent(event) {
+    if (this.isDisabled) {
+      return;
+    }
+    this.addScoreToBuffer(event);
+    await this.handleBufferedEvent();
+  }
+  async onFeedbackEvent(event) {
+    if (this.isDisabled) {
+      return;
+    }
+    this.addFeedbackToBuffer(event);
+    await this.handleBufferedEvent();
+  }
+  addToBuffer(event) {
+    this.markBufferStart();
+    const spanRecord = this.formatSpan(event.exportedSpan);
+    this.buffer.spans.push(spanRecord);
+    this.buffer.totalSize++;
+  }
+  addLogToBuffer(event) {
+    this.markBufferStart();
+    this.buffer.logs.push(this.formatLog(event.log));
+    this.buffer.totalSize++;
+  }
+  addMetricToBuffer(event) {
+    this.markBufferStart();
+    this.buffer.metrics.push(this.formatMetric(event.metric));
+    this.buffer.totalSize++;
+  }
+  addScoreToBuffer(event) {
+    this.markBufferStart();
+    this.buffer.scores.push(this.formatScore(event.score));
+    this.buffer.totalSize++;
+  }
+  addFeedbackToBuffer(event) {
+    this.markBufferStart();
+    this.buffer.feedback.push(this.formatFeedback(event.feedback));
+    this.buffer.totalSize++;
+  }
+  markBufferStart() {
+    if (this.buffer.totalSize === 0) {
+      this.buffer.firstEventTime = /* @__PURE__ */ new Date();
+    }
+  }
+  formatSpan(span) {
+    const spanRecord = {
+      ...span,
+      spanId: span.id,
+      spanType: span.type,
+      startedAt: span.startTime,
+      endedAt: span.endTime ?? null,
+      error: span.errorInfo ?? null,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: null
+    };
+    return spanRecord;
+  }
+  formatLog(log) {
+    return {
+      ...log
+    };
+  }
+  formatMetric(metric) {
+    return {
+      ...metric
+    };
+  }
+  formatScore(score) {
+    return {
+      ...score
+    };
+  }
+  formatFeedback(feedback) {
+    return {
+      ...feedback
+    };
+  }
+  async handleBufferedEvent() {
+    if (this.shouldFlush()) {
+      void this.flush().catch((error48) => {
+        this.logger.error("Batch flush failed", {
+          error: error48 instanceof Error ? error48.message : String(error48)
+        });
+      });
+    } else if (this.buffer.totalSize === 1) {
+      this.scheduleFlush();
+    }
+  }
+  shouldFlush() {
+    if (this.buffer.totalSize >= this.platformConfig.maxBatchSize) {
+      return true;
+    }
+    if (this.buffer.firstEventTime && this.buffer.totalSize > 0) {
+      const elapsed = Date.now() - this.buffer.firstEventTime.getTime();
+      if (elapsed >= this.platformConfig.maxBatchWaitMs) {
+        return true;
+      }
+    }
+    return false;
+  }
+  scheduleFlush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flushTimer = setTimeout(() => {
+      void this.flush().catch((error48) => {
+        const mastraError = new error$1.MastraError(
+          {
+            id: `MASTRA_PLATFORM_EXPORTER_FAILED_TO_SCHEDULE_FLUSH`,
+            domain: error$1.ErrorDomain.MASTRA_OBSERVABILITY,
+            category: error$1.ErrorCategory.USER
+          },
+          error48
+        );
+        this.logger.trackException(mastraError);
+        this.logger.error("Scheduled flush failed", mastraError);
+      });
+    }, this.platformConfig.maxBatchWaitMs);
+  }
+  async flushBuffer() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.buffer.totalSize === 0) {
+      return;
+    }
+    const startTime = Date.now();
+    const spansCopy = [...this.buffer.spans];
+    const logsCopy = [...this.buffer.logs];
+    const metricsCopy = [...this.buffer.metrics];
+    const scoresCopy = [...this.buffer.scores];
+    const feedbackCopy = [...this.buffer.feedback];
+    const batchSize = this.buffer.totalSize;
+    const flushReason = this.buffer.totalSize >= this.platformConfig.maxBatchSize ? "size" : "time";
+    this.resetBuffer();
+    const results = await Promise.all([
+      this.flushSignalBatch("traces", spansCopy),
+      this.flushSignalBatch("logs", logsCopy),
+      this.flushSignalBatch("metrics", metricsCopy),
+      this.flushSignalBatch("scores", scoresCopy),
+      this.flushSignalBatch("feedback", feedbackCopy)
+    ]);
+    const failedSignals = results.filter((result) => !result.succeeded).map((result) => result.signal);
+    const elapsed = Date.now() - startTime;
+    if (failedSignals.length === 0) {
+      this.logger.debug("Batch flushed successfully", {
+        batchSize,
+        flushReason,
+        durationMs: elapsed
+      });
+      return;
+    }
+    this.logger.warn("Batch flush completed with dropped signal batches", {
+      batchSize,
+      flushReason,
+      durationMs: elapsed,
+      failedSignals
+    });
+  }
+  /**
+   * Uploads a signal batch to the configured Mastra Observability API using fetchWithRetry.
+   */
+  async batchUpload(signal, records) {
+    const headers = {
+      Authorization: `Bearer ${this.platformConfig.accessToken}`,
+      "Content-Type": "application/json"
+    };
+    const endpointMap = {
+      traces: this.platformConfig.tracesEndpoint,
+      logs: this.platformConfig.logsEndpoint,
+      metrics: this.platformConfig.metricsEndpoint,
+      scores: this.platformConfig.scoresEndpoint,
+      feedback: this.platformConfig.feedbackEndpoint
+    };
+    const options = {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ [SIGNAL_PUBLISH_SEGMENTS2[signal]]: records })
+    };
+    await utils.fetchWithRetry(endpointMap[signal], options, this.platformConfig.maxRetries);
+  }
+  async flushSignalBatch(signal, records) {
+    if (records.length === 0) {
+      return { signal, succeeded: true };
+    }
+    try {
+      await this.batchUpload(signal, records);
+      return { signal, succeeded: true };
+    } catch (error48) {
+      const errorId = `MASTRA_PLATFORM_EXPORTER_FAILED_TO_BATCH_UPLOAD_${signal.toUpperCase()}`;
+      const mastraError = new error$1.MastraError(
+        {
+          id: errorId,
+          domain: error$1.ErrorDomain.MASTRA_OBSERVABILITY,
+          category: error$1.ErrorCategory.USER,
+          details: {
+            signal,
+            droppedBatchSize: records.length
+          }
+        },
+        error48
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Batch upload failed after all retries, dropping batch", mastraError);
+      return { signal, succeeded: false };
+    }
+  }
+  resetBuffer() {
+    this.buffer.spans = [];
+    this.buffer.logs = [];
+    this.buffer.metrics = [];
+    this.buffer.scores = [];
+    this.buffer.feedback = [];
+    this.buffer.firstEventTime = void 0;
+    this.buffer.totalSize = 0;
+  }
+  /**
+   * Force flush any buffered events without shutting down the exporter.
+   * This is useful in serverless environments where you need to ensure events
+   * are exported before the runtime instance is terminated.
+   */
+  async flush() {
+    if (this.isDisabled) {
+      return;
+    }
+    while (this.buffer.totalSize > 0 || this.inFlightFlushes.size > 0) {
+      if (this.buffer.totalSize > 0) {
+        this.logger.debug("Flushing buffered events", {
+          bufferedEvents: this.buffer.totalSize
+        });
+        const flushPromise = this.flushBuffer();
+        this.inFlightFlushes.add(flushPromise);
+        try {
+          await flushPromise;
+        } finally {
+          this.inFlightFlushes.delete(flushPromise);
+        }
+        continue;
+      }
+      await Promise.allSettled([...this.inFlightFlushes]);
+    }
+  }
+  async shutdown() {
+    if (this.isDisabled) {
+      return;
+    }
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    try {
+      await this.flush();
+    } catch (error48) {
+      const mastraError = new error$1.MastraError(
+        {
+          id: `MASTRA_PLATFORM_EXPORTER_FAILED_TO_FLUSH_REMAINING_EVENTS_DURING_SHUTDOWN`,
+          domain: error$1.ErrorDomain.MASTRA_OBSERVABILITY,
+          category: error$1.ErrorCategory.USER,
+          details: {
+            remainingEvents: this.buffer.totalSize
+          }
+        },
+        error48
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Failed to flush remaining events during shutdown", mastraError);
+    }
+    this.logger.info("MastraPlatformExporter shutdown complete");
+  }
+};
+function resolveTracingStorageStrategy2(config2, observabilityStorage, storageName, logger) {
+  const observabilityStrategy = observabilityStorage.observabilityStrategy;
+  if (config2.strategy && config2.strategy !== "auto") {
+    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: observabilityStrategy.supported,
+      fallbackStrategy: observabilityStrategy.preferred
+    });
+  }
+  return observabilityStrategy.preferred;
+}
+var MastraStorageExporter = class extends BaseExporter {
+  name = "mastra-storage-exporter";
+  #config;
+  #isInitializing = false;
+  #initPromises = /* @__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);
+    this.#config = {
+      ...config2,
+      maxBatchSize: config2.maxBatchSize ?? 1e3,
+      maxBufferSize: config2.maxBufferSize ?? 1e4,
+      maxBatchWaitMs: config2.maxBatchWaitMs ?? 5e3,
+      maxRetries: config2.maxRetries ?? 4,
+      retryDelayMs: config2.retryDelayMs ?? 500,
+      strategy: config2.strategy ?? "auto"
+    };
+    this.#eventBuffer = new EventBuffer({ maxRetries: this.#config.maxRetries ?? 4 });
+  }
+  /**
+   * Initialize the exporter (called after all dependencies are ready)
+   */
+  async init(options) {
+    try {
+      this.#isInitializing = true;
+      this.#storage = options.mastra?.getStorage();
+      if (!this.#storage) {
+        this.logger.warn("MastraStorageExporter disabled: Storage not available. Traces will not be persisted.");
+        return;
+      }
+      this.#observabilityStorage = await this.#storage.getStore("observability");
+      if (!this.#observabilityStorage) {
+        this.logger.warn(
+          "MastraStorageExporter disabled: Observability storage not available. Traces will not be persisted."
+        );
+        return;
+      }
+      if (!this.#resolvedStrategy) {
+        this.#resolvedStrategy = resolveTracingStorageStrategy2(
+          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) => {
+        resolve();
+      });
+      this.#initPromises.clear();
+    }
+  }
+  /**
+   * Checks if buffer should be flushed based on size or time triggers
+   */
+  shouldFlush() {
+    if (this.#resolvedStrategy === "realtime") {
+      return true;
+    }
+    if (this.#eventBuffer.totalSize >= this.#config.maxBufferSize) {
+      return true;
+    }
+    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;
+  }
+  /**
+   * Schedules a flush using setTimeout
+   */
+  scheduleFlush() {
+    if (this.#flushTimer) {
+      clearTimeout(this.#flushTimer);
+    }
+    this.#flushTimer = setTimeout(() => {
+      this.flushBuffer().catch((error48) => {
+        this.logger.error("Scheduled flush failed", {
+          error: error48 instanceof Error ? error48.message : String(error48)
+        });
+      });
+    }, this.#config.maxBatchWaitMs);
+  }
+  /**
+   * 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.
+   */
+  async handleBatchedFlush() {
+    if (this.shouldFlush()) {
+      await this.flushBuffer();
+    } else if (this.#eventBuffer.totalSize === 1) {
+      this.scheduleFlush();
+    }
+  }
+  /**
+   * 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;
+    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);
+      } else {
+        this.#eventBuffer.reAddCreates(events);
+      }
+    }
+  }
+  /**
+   * 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.
+   */
+  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: storage.buildUpdateSpanRecord(span)
+        });
+      } else {
+        deferredUpdates.push(event);
+      }
+    }
+    if (partials.length === 0) return;
+    try {
+      await this.#observabilityStorage.batchUpdateSpans({ records: partials });
+      if (isEnd) {
+        this.#eventBuffer.endFinishedSpans({ records: partials });
+      }
+    } 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("tracing");
+      } else {
+        deferredUpdates.length = 0;
+        this.#eventBuffer.reAddUpdates(events);
+      }
+    }
+  }
+  /**
+   * 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.#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 = void 0;
+    }
+    if (this.#eventBuffer.totalSize === 0) {
+      return;
+    }
+    const startTime = Date.now();
+    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 observability.TracingEventType.SPAN_UPDATED:
+          updateSpanEvents.push(updateEvent);
+          break;
+        case observability.TracingEventType.SPAN_ENDED:
+          endSpanEvents.push(updateEvent);
+          break;
+      }
+    }
+    await Promise.all([
+      this.flushCreates(
+        "feedback",
+        createFeedbackEvents,
+        (events) => this.#observabilityStorage.batchCreateFeedback({ feedbacks: events.map((f) => storage.buildFeedbackRecord(f)) })
+      ),
+      this.flushCreates(
+        "logs",
+        createLogEvents,
+        (events) => this.#observabilityStorage.batchCreateLogs({ logs: events.map((l) => storage.buildLogRecord(l)) })
+      ),
+      this.flushCreates(
+        "metrics",
+        createMetricEvents,
+        (events) => this.#observabilityStorage.batchCreateMetrics({ metrics: events.map((m) => storage.buildMetricRecord(m)) })
+      ),
+      this.flushCreates(
+        "scores",
+        createScoreEvents,
+        (events) => this.#observabilityStorage.batchCreateScores({ scores: events.map((s) => storage.buildScoreRecord(s)) })
+      ),
+      this.flushCreates("tracing", createSpanEvents, async (events) => {
+        const records = events.map((t) => storage.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,
+      durationMs: elapsed,
+      deferredUpdates: deferredUpdates.length > 0 ? deferredUpdates.length : void 0
+    });
+    return;
+  }
+  async _exportTracingEvent(event) {
+    await this.waitForInit();
+    if (!this.#observabilityStorage) {
+      this.logger.debug("Cannot store traces. Observability storage is not initialized");
+      return;
+    }
+    this.#eventBuffer.addEvent(event);
+    await this.handleBatchedFlush();
+  }
+  /**
+   * Resolves when an ongoing init call is finished
+   * Doesn't wait for the caller to call init
+   * @returns
+   */
+  async waitForInit() {
+    if (!this.#isInitializing) return;
+    return new Promise((resolve) => {
+      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.#eventBuffer.totalSize > 0) {
+      this.logger.debug("Flushing buffered events", {
+        bufferedEvents: this.#eventBuffer.totalSize
+      });
+      await this.flushBuffer();
+    }
+  }
+  async shutdown() {
+    if (this.#flushTimer) {
+      clearTimeout(this.#flushTimer);
+      this.#flushTimer = void 0;
+    }
+    await this.flush();
+    this.logger.info("MastraStorageExporter shutdown complete");
+  }
+};
 var _snapshotsDir;
 async function getSnapshotsDir() {
   if (!_snapshotsDir) {
@@ -19035,7 +19881,8 @@ var ModelSpanTracker = class {
         ...payload?.messageId ? { messageId: payload.messageId } : {},
         ...payload?.warnings?.length ? { warnings: payload.warnings } : {}
       },
-      input
+      input,
+      tracingPolicy: this.#modelSpan?.tracingPolicy
     });
     this.#currentStepInputIsFinal = Array.isArray(payload?.inputMessages);
     this.#chunkSequence = 0;
@@ -19102,7 +19949,8 @@ var ModelSpanTracker = class {
         ...ctx?.toolChoice !== void 0 ? { toolChoice: ctx.toolChoice } : {},
         ...ctx?.responseFormat !== void 0 ? { responseFormat: ctx.responseFormat } : {}
       },
-      input
+      input,
+      tracingPolicy: this.#modelSpan?.tracingPolicy
     });
   }
   /**
@@ -19195,7 +20043,8 @@ var ModelSpanTracker = class {
       attributes: {
         chunkType,
         sequenceNumber: this.#chunkSequence
-      }
+      },
+      tracingPolicy: this.#modelSpan?.tracingPolicy
     });
     this.#currentChunkType = chunkType;
     this.#accumulator = initialData || {};
@@ -19238,7 +20087,8 @@ var ModelSpanTracker = class {
         ...options?.attributes
       },
       metadata: options?.metadata,
-      output
+      output,
+      tracingPolicy: this.#modelSpan?.tracingPolicy
     });
     if (span) {
       this.#chunkSequence++;
@@ -19358,7 +20208,8 @@ var ModelSpanTracker = class {
         chunkType: "tool-call-approval",
         sequenceNumber: this.#chunkSequence
       },
-      output: payload
+      output: payload,
+      tracingPolicy: this.#modelSpan?.tracingPolicy
     });
     if (span) {
       this.#chunkSequence++;
@@ -21156,14 +22007,14 @@ var Observability = class extends base.MastraBase {
     };
     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 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.'
+        '[Mastra Observability] The "default: { enabled: true }" configuration is deprecated and will be removed in a future version. Please use explicit configs with MastraStorageExporter and MastraPlatformExporter 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()],
+        exporters: [new MastraStorageExporter(), new MastraPlatformExporter()],
         spanOutputProcessors: autoFilter ? [autoFilter] : []
       });
       this.#registry.register("default", defaultInstance, true);
@@ -21427,6 +22278,8 @@ exports.DefaultObservabilityInstance = DefaultObservabilityInstance;
 exports.DefaultSpan = DefaultSpan;
 exports.JsonExporter = JsonExporter;
 exports.LoggerContextImpl = LoggerContextImpl;
+exports.MastraPlatformExporter = MastraPlatformExporter;
+exports.MastraStorageExporter = MastraStorageExporter;
 exports.MetricsContextImpl = MetricsContextImpl;
 exports.ModelSpanTracker = ModelSpanTracker;
 exports.NoOpSpan = NoOpSpan;