@mastra/observability 0.0.0-fix-9244-clickhouse-metadata-20251104223105 → 0.0.0-fix-thread-list-20251105222841

package/dist/index.js

@@ -1,1763 +1,1860 @@
 import { MastraBase } from '@mastra/core/base';
-import { RegisteredLogger, ConsoleLogger, LogLevel } from '@mastra/core/logger';
-import { AISpanType, SamplingStrategyType, AITracingEventType, InternalSpans } from '@mastra/core/observability';
-import { getNestedValue, setNestedValue, fetchWithRetry } from '@mastra/core/utils';
-import { TransformStream } from 'stream/web';
+import { ConsoleLogger, LogLevel, RegisteredLogger } from '@mastra/core/logger';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
+import { TracingEventType, SpanType, InternalSpans } from '@mastra/core/observability';
+import { fetchWithRetry, getNestedValue, setNestedValue } from '@mastra/core/utils';
+import { TransformStream } from 'stream/web';
 
-// src/tracers/base.ts
-var ModelSpanTracker = class {
-  #modelSpan;
-  #currentStepSpan;
-  #currentChunkSpan;
-  #accumulator = {};
-  #stepIndex = 0;
-  #chunkSequence = 0;
-  constructor(modelSpan) {
-    this.#modelSpan = modelSpan;
-  }
-  /**
-   * Get the tracing context for creating child spans.
-   * Returns the current step span if active, otherwise the model span.
-   */
-  getTracingContext() {
-    return {
-      currentSpan: this.#currentStepSpan ?? this.#modelSpan
-    };
-  }
+// src/default.ts
+
+// src/config.ts
+var SamplingStrategyType = /* @__PURE__ */ ((SamplingStrategyType2) => {
+  SamplingStrategyType2["ALWAYS"] = "always";
+  SamplingStrategyType2["NEVER"] = "never";
+  SamplingStrategyType2["RATIO"] = "ratio";
+  SamplingStrategyType2["CUSTOM"] = "custom";
+  return SamplingStrategyType2;
+})(SamplingStrategyType || {});
+var BaseExporter = class {
+  /** Mastra logger instance */
+  logger;
+  /** Whether this exporter is disabled */
+  isDisabled = false;
   /**
-   * Report an error on the generation span
+   * Initialize the base exporter with logger
    */
-  reportGenerationError(options) {
-    this.#modelSpan?.error(options);
+  constructor(config = {}) {
+    const logLevel = this.resolveLogLevel(config.logLevel);
+    this.logger = config.logger ?? new ConsoleLogger({ level: logLevel, name: this.constructor.name });
   }
   /**
-   * End the generation span
+   * Set the logger for the exporter (called by Mastra/ObservabilityInstance during initialization)
    */
-  endGeneration(options) {
-    this.#modelSpan?.end(options);
+  __setLogger(logger) {
+    this.logger = logger;
+    this.logger.debug(`Logger updated for exporter [name=${this.name}]`);
   }
   /**
-   * Update the generation span
+   * Convert string log level to LogLevel enum
    */
-  updateGeneration(options) {
-    this.#modelSpan?.update(options);
+  resolveLogLevel(logLevel) {
+    if (!logLevel) {
+      return LogLevel.INFO;
+    }
+    if (typeof logLevel === "number") {
+      return logLevel;
+    }
+    const logLevelMap = {
+      debug: LogLevel.DEBUG,
+      info: LogLevel.INFO,
+      warn: LogLevel.WARN,
+      error: LogLevel.ERROR
+    };
+    return logLevelMap[logLevel] ?? LogLevel.INFO;
   }
   /**
-   * Start a new Model execution step
+   * Mark the exporter as disabled and log a message
+   *
+   * @param reason - Reason why the exporter is disabled
    */
-  #startStepSpan(payload) {
-    this.#currentStepSpan = this.#modelSpan?.createChildSpan({
-      name: `step: ${this.#stepIndex}`,
-      type: AISpanType.MODEL_STEP,
-      attributes: {
-        stepIndex: this.#stepIndex,
-        ...payload?.messageId ? { messageId: payload.messageId } : {},
-        ...payload?.warnings?.length ? { warnings: payload.warnings } : {}
-      },
-      input: payload?.request
-    });
-    this.#chunkSequence = 0;
+  setDisabled(reason) {
+    this.isDisabled = true;
+    this.logger.warn(`${this.name} disabled: ${reason}`);
   }
   /**
-   * End the current Model execution step with token usage, finish reason, output, and metadata
+   * Export a tracing event
+   *
+   * This method checks if the exporter is disabled before calling _exportEvent.
+   * Subclasses should implement _exportEvent instead of overriding this method.
    */
-  #endStepSpan(payload) {
-    if (!this.#currentStepSpan) return;
-    const output = payload.output;
-    const { usage, ...otherOutput } = output;
-    const stepResult = payload.stepResult;
-    const metadata = payload.metadata;
-    const cleanMetadata = metadata ? { ...metadata } : void 0;
-    if (cleanMetadata?.request) {
-      delete cleanMetadata.request;
+  async exportTracingEvent(event) {
+    if (this.isDisabled) {
+      return;
     }
-    this.#currentStepSpan.end({
-      output: otherOutput,
-      attributes: {
-        usage,
-        isContinued: stepResult.isContinued,
-        finishReason: stepResult.reason,
-        warnings: stepResult.warnings
-      },
-      metadata: {
-        ...cleanMetadata
-      }
-    });
-    this.#currentStepSpan = void 0;
-    this.#stepIndex++;
+    await this._exportTracingEvent(event);
   }
   /**
-   * Create a new chunk span (for multi-part chunks like text-start/delta/end)
+   * Shutdown the exporter and clean up resources
+   *
+   * Default implementation just logs. Override to add custom cleanup.
    */
-  #startChunkSpan(chunkType, initialData) {
-    if (!this.#currentStepSpan) {
-      this.#startStepSpan();
-    }
-    this.#currentChunkSpan = this.#currentStepSpan?.createChildSpan({
-      name: `chunk: '${chunkType}'`,
-      type: AISpanType.MODEL_CHUNK,
-      attributes: {
-        chunkType,
-        sequenceNumber: this.#chunkSequence
-      }
-    });
-    this.#accumulator = initialData || {};
+  async shutdown() {
+    this.logger.info(`${this.name} shutdown complete`);
   }
-  /**
-   * Append string content to a specific field in the accumulator
-   */
-  #appendToAccumulator(field, text) {
-    if (this.#accumulator[field] === void 0) {
-      this.#accumulator[field] = text;
-    } else {
-      this.#accumulator[field] += text;
+};
+var CloudExporter = class extends BaseExporter {
+  name = "mastra-cloud-observability-exporter";
+  config;
+  buffer;
+  flushTimer = null;
+  constructor(config = {}) {
+    super(config);
+    const accessToken = config.accessToken ?? process.env.MASTRA_CLOUD_ACCESS_TOKEN;
+    if (!accessToken) {
+      this.setDisabled(
+        "MASTRA_CLOUD_ACCESS_TOKEN environment variable not set. \u{1F680} Sign up for Mastra Cloud at https://cloud.mastra.ai to see your traces online and obtain your access token."
+      );
     }
+    const endpoint = config.endpoint ?? process.env.MASTRA_CLOUD_AI_TRACES_ENDPOINT ?? "https://api.mastra.ai/ai/spans/publish";
+    this.config = {
+      logger: this.logger,
+      logLevel: config.logLevel ?? LogLevel.INFO,
+      maxBatchSize: config.maxBatchSize ?? 1e3,
+      maxBatchWaitMs: config.maxBatchWaitMs ?? 5e3,
+      maxRetries: config.maxRetries ?? 3,
+      accessToken: accessToken || "",
+      endpoint
+    };
+    this.buffer = {
+      spans: [],
+      totalSize: 0
+    };
   }
-  /**
-   * End the current chunk span.
-   * Safe to call multiple times - will no-op if span already ended.
-   */
-  #endChunkSpan(output) {
-    if (!this.#currentChunkSpan) return;
-    this.#currentChunkSpan.end({
-      output: output !== void 0 ? output : this.#accumulator
-    });
-    this.#currentChunkSpan = void 0;
-    this.#accumulator = {};
-    this.#chunkSequence++;
-  }
-  /**
-   * Create an event span (for single chunks like tool-call)
-   */
-  #createEventSpan(chunkType, output) {
-    if (!this.#currentStepSpan) {
-      this.#startStepSpan();
+  async _exportTracingEvent(event) {
+    if (event.type !== TracingEventType.SPAN_ENDED) {
+      return;
     }
-    const span = this.#currentStepSpan?.createEventSpan({
-      name: `chunk: '${chunkType}'`,
-      type: AISpanType.MODEL_CHUNK,
-      attributes: {
-        chunkType,
-        sequenceNumber: this.#chunkSequence
-      },
-      output
-    });
-    if (span) {
-      this.#chunkSequence++;
+    this.addToBuffer(event);
+    if (this.shouldFlush()) {
+      this.flush().catch((error) => {
+        this.logger.error("Batch flush failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    } else if (this.buffer.totalSize === 1) {
+      this.scheduleFlush();
     }
   }
-  /**
-   * Check if there is currently an active chunk span
-   */
-  #hasActiveChunkSpan() {
-    return !!this.#currentChunkSpan;
+  addToBuffer(event) {
+    if (this.buffer.totalSize === 0) {
+      this.buffer.firstEventTime = /* @__PURE__ */ new Date();
+    }
+    const spanRecord = this.formatSpan(event.exportedSpan);
+    this.buffer.spans.push(spanRecord);
+    this.buffer.totalSize++;
   }
-  /**
-   * Get the current accumulator value
-   */
-  #getAccumulator() {
-    return this.#accumulator;
+  formatSpan(span) {
+    const spanRecord = {
+      traceId: span.traceId,
+      spanId: span.id,
+      parentSpanId: span.parentSpanId ?? null,
+      name: span.name,
+      spanType: span.type,
+      attributes: span.attributes ?? null,
+      metadata: span.metadata ?? null,
+      startedAt: span.startTime,
+      endedAt: span.endTime ?? null,
+      input: span.input ?? null,
+      output: span.output ?? null,
+      error: span.errorInfo,
+      isEvent: span.isEvent,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: null
+    };
+    return spanRecord;
   }
-  /**
-   * Handle text chunk spans (text-start/delta/end)
-   */
-  #handleTextChunk(chunk) {
-    switch (chunk.type) {
-      case "text-start":
-        this.#startChunkSpan("text");
-        break;
-      case "text-delta":
-        this.#appendToAccumulator("text", chunk.payload.text);
-        break;
-      case "text-end": {
-        this.#endChunkSpan();
-        break;
+  shouldFlush() {
+    if (this.buffer.totalSize >= this.config.maxBatchSize) {
+      return true;
+    }
+    if (this.buffer.firstEventTime && this.buffer.totalSize > 0) {
+      const elapsed = Date.now() - this.buffer.firstEventTime.getTime();
+      if (elapsed >= this.config.maxBatchWaitMs) {
+        return true;
       }
     }
+    return false;
   }
-  /**
-   * Handle reasoning chunk spans (reasoning-start/delta/end)
-   */
-  #handleReasoningChunk(chunk) {
-    switch (chunk.type) {
-      case "reasoning-start":
-        this.#startChunkSpan("reasoning");
-        break;
-      case "reasoning-delta":
-        this.#appendToAccumulator("text", chunk.payload.text);
-        break;
-      case "reasoning-end": {
-        this.#endChunkSpan();
-        break;
-      }
+  scheduleFlush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flush().catch((error) => {
+        const mastraError = new MastraError(
+          {
+            id: `CLOUD_EXPORTER_FAILED_TO_SCHEDULE_FLUSH`,
+            domain: ErrorDomain.MASTRA_OBSERVABILITY,
+            category: ErrorCategory.USER
+          },
+          error
+        );
+        this.logger.trackException(mastraError);
+        this.logger.error("Scheduled flush failed", mastraError);
+      });
+    }, this.config.maxBatchWaitMs);
+  }
+  async flush() {
+    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 flushReason = this.buffer.totalSize >= this.config.maxBatchSize ? "size" : "time";
+    this.resetBuffer();
+    try {
+      await this.batchUpload(spansCopy);
+      const elapsed = Date.now() - startTime;
+      this.logger.debug("Batch flushed successfully", {
+        batchSize: spansCopy.length,
+        flushReason,
+        durationMs: elapsed
+      });
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: `CLOUD_EXPORTER_FAILED_TO_BATCH_UPLOAD`,
+          domain: ErrorDomain.MASTRA_OBSERVABILITY,
+          category: ErrorCategory.USER,
+          details: {
+            droppedBatchSize: spansCopy.length
+          }
+        },
+        error
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Batch upload failed after all retries, dropping batch", mastraError);
     }
   }
   /**
-   * Handle tool call chunk spans (tool-call-input-streaming-start/delta/end, tool-call)
+   * Uploads spans to cloud API using fetchWithRetry for all retry logic
    */
-  #handleToolCallChunk(chunk) {
-    switch (chunk.type) {
-      case "tool-call-input-streaming-start":
-        this.#startChunkSpan("tool-call", {
-          toolName: chunk.payload.toolName,
-          toolCallId: chunk.payload.toolCallId
-        });
+  async batchUpload(spans) {
+    const headers = {
+      Authorization: `Bearer ${this.config.accessToken}`,
+      "Content-Type": "application/json"
+    };
+    const options = {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ spans })
+    };
+    await fetchWithRetry(this.config.endpoint, options, this.config.maxRetries);
+  }
+  resetBuffer() {
+    this.buffer.spans = [];
+    this.buffer.firstEventTime = void 0;
+    this.buffer.totalSize = 0;
+  }
+  async shutdown() {
+    if (this.isDisabled) {
+      return;
+    }
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.buffer.totalSize > 0) {
+      this.logger.info("Flushing remaining events on shutdown", {
+        remainingEvents: this.buffer.totalSize
+      });
+      try {
+        await this.flush();
+      } catch (error) {
+        const mastraError = new MastraError(
+          {
+            id: `CLOUD_EXPORTER_FAILED_TO_FLUSH_REMAINING_EVENTS_DURING_SHUTDOWN`,
+            domain: ErrorDomain.MASTRA_OBSERVABILITY,
+            category: ErrorCategory.USER,
+            details: {
+              remainingEvents: this.buffer.totalSize
+            }
+          },
+          error
+        );
+        this.logger.trackException(mastraError);
+        this.logger.error("Failed to flush remaining events during shutdown", mastraError);
+      }
+    }
+    this.logger.info("CloudExporter shutdown complete");
+  }
+};
+var ConsoleExporter = class extends BaseExporter {
+  name = "tracing-console-exporter";
+  constructor(config = {}) {
+    super(config);
+  }
+  async _exportTracingEvent(event) {
+    const span = event.exportedSpan;
+    const formatAttributes = (attributes) => {
+      try {
+        return JSON.stringify(attributes, null, 2);
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : "Unknown formatting error";
+        return `[Unable to serialize attributes: ${errMsg}]`;
+      }
+    };
+    const formatDuration = (startTime, endTime) => {
+      if (!endTime) return "N/A";
+      const duration = endTime.getTime() - startTime.getTime();
+      return `${duration}ms`;
+    };
+    switch (event.type) {
+      case TracingEventType.SPAN_STARTED:
+        this.logger.info(`\u{1F680} SPAN_STARTED`);
+        this.logger.info(`   Type: ${span.type}`);
+        this.logger.info(`   Name: ${span.name}`);
+        this.logger.info(`   ID: ${span.id}`);
+        this.logger.info(`   Trace ID: ${span.traceId}`);
+        if (span.input !== void 0) {
+          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
+        }
+        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
+        this.logger.info("\u2500".repeat(80));
         break;
-      case "tool-call-delta":
-        this.#appendToAccumulator("toolInput", chunk.payload.argsTextDelta);
+      case TracingEventType.SPAN_ENDED:
+        const duration = formatDuration(span.startTime, span.endTime);
+        this.logger.info(`\u2705 SPAN_ENDED`);
+        this.logger.info(`   Type: ${span.type}`);
+        this.logger.info(`   Name: ${span.name}`);
+        this.logger.info(`   ID: ${span.id}`);
+        this.logger.info(`   Duration: ${duration}`);
+        this.logger.info(`   Trace ID: ${span.traceId}`);
+        if (span.input !== void 0) {
+          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
+        }
+        if (span.output !== void 0) {
+          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
+        }
+        if (span.errorInfo) {
+          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
+        }
+        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
+        this.logger.info("\u2500".repeat(80));
         break;
-      case "tool-call-input-streaming-end":
-      case "tool-call": {
-        const acc = this.#getAccumulator();
-        let toolInput;
-        try {
-          toolInput = acc.toolInput ? JSON.parse(acc.toolInput) : {};
-        } catch {
-          toolInput = acc.toolInput;
+      case TracingEventType.SPAN_UPDATED:
+        this.logger.info(`\u{1F4DD} SPAN_UPDATED`);
+        this.logger.info(`   Type: ${span.type}`);
+        this.logger.info(`   Name: ${span.name}`);
+        this.logger.info(`   ID: ${span.id}`);
+        this.logger.info(`   Trace ID: ${span.traceId}`);
+        if (span.input !== void 0) {
+          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
         }
-        this.#endChunkSpan({
-          toolName: acc.toolName,
-          toolCallId: acc.toolCallId,
-          toolInput
-        });
+        if (span.output !== void 0) {
+          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
+        }
+        if (span.errorInfo) {
+          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
+        }
+        this.logger.info(`   Updated Attributes: ${formatAttributes(span.attributes)}`);
+        this.logger.info("\u2500".repeat(80));
         break;
-      }
+      default:
+        this.logger.warn(`Tracing event type not implemented: ${event.type}`);
     }
   }
+  async shutdown() {
+    this.logger.info("ConsoleExporter shutdown");
+  }
+};
+function resolveTracingStorageStrategy(config, storage, logger) {
+  if (config.strategy && config.strategy !== "auto") {
+    const hints = storage.tracingStrategy;
+    if (hints.supported.includes(config.strategy)) {
+      return config.strategy;
+    }
+    logger.warn("User-specified tracing strategy not supported by storage adapter, falling back to auto-selection", {
+      userStrategy: config.strategy,
+      storageAdapter: storage.constructor.name,
+      supportedStrategies: hints.supported,
+      fallbackStrategy: hints.preferred
+    });
+  }
+  return storage.tracingStrategy.preferred;
+}
+var DefaultExporter = class extends BaseExporter {
+  name = "mastra-default-observability-exporter";
+  #storage;
+  #config;
+  #resolvedStrategy;
+  buffer;
+  #flushTimer = null;
+  // Track all spans that have been created, persists across flushes
+  allCreatedSpans = /* @__PURE__ */ new Set();
+  constructor(config = {}) {
+    super(config);
+    if (config === void 0) {
+      config = {};
+    }
+    this.#config = {
+      ...config,
+      maxBatchSize: config.maxBatchSize ?? 1e3,
+      maxBufferSize: config.maxBufferSize ?? 1e4,
+      maxBatchWaitMs: config.maxBatchWaitMs ?? 5e3,
+      maxRetries: config.maxRetries ?? 4,
+      retryDelayMs: config.retryDelayMs ?? 500,
+      strategy: config.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";
+  }
+  #strategyInitialized = false;
   /**
-   * Handle object chunk spans (object, object-result)
+   * Initialize the exporter (called after all dependencies are ready)
    */
-  #handleObjectChunk(chunk) {
-    switch (chunk.type) {
-      case "object":
-        if (!this.#hasActiveChunkSpan()) {
-          this.#startChunkSpan("object");
-        }
-        break;
-      case "object-result":
-        this.#endChunkSpan(chunk.object);
-        break;
+  init(options) {
+    this.#storage = options.mastra?.getStorage();
+    if (!this.#storage) {
+      this.logger.warn("DefaultExporter disabled: Storage not available. Traces will not be persisted.");
+      return;
     }
+    this.initializeStrategy(this.#storage);
   }
   /**
-   * Wraps a stream with model tracing transform to track MODEL_STEP and MODEL_CHUNK spans.
-   *
-   * This should be added to the stream pipeline to automatically
-   * create MODEL_STEP and MODEL_CHUNK spans for each semantic unit in the stream.
+   * Initialize the resolved strategy once storage is available
    */
-  wrapStream(stream) {
-    return stream.pipeThrough(
-      new TransformStream({
-        transform: (chunk, controller) => {
-          controller.enqueue(chunk);
-          switch (chunk.type) {
-            case "text-start":
-            case "text-delta":
-            case "text-end":
-              this.#handleTextChunk(chunk);
-              break;
-            case "tool-call-input-streaming-start":
-            case "tool-call-delta":
-            case "tool-call-input-streaming-end":
-            case "tool-call":
-              this.#handleToolCallChunk(chunk);
-              break;
-            case "reasoning-start":
-            case "reasoning-delta":
-            case "reasoning-end":
-              this.#handleReasoningChunk(chunk);
-              break;
-            case "object":
-            case "object-result":
-              this.#handleObjectChunk(chunk);
-              break;
-            case "step-start":
-              this.#startStepSpan(chunk.payload);
-              break;
-            case "step-finish":
-              this.#endStepSpan(chunk.payload);
-              break;
-            case "raw":
-            // Skip raw chunks as they're redundant
-            case "start":
-            case "finish":
-              break;
-            // Default: auto-create event span for all other chunk types
-            default: {
-              let outputPayload = chunk.payload;
-              if (outputPayload && typeof outputPayload === "object" && "data" in outputPayload) {
-                const typedPayload = outputPayload;
-                outputPayload = { ...typedPayload };
-                if (typedPayload.data) {
-                  outputPayload.size = typeof typedPayload.data === "string" ? typedPayload.data.length : typedPayload.data instanceof Uint8Array ? typedPayload.data.length : void 0;
-                  delete outputPayload.data;
-                }
-              }
-              this.#createEventSpan(chunk.type, outputPayload);
-              break;
-            }
+  initializeStrategy(storage) {
+    if (this.#strategyInitialized) return;
+    this.#resolvedStrategy = resolveTracingStorageStrategy(this.#config, storage, this.logger);
+    this.#strategyInitialized = true;
+    this.logger.debug("tracing storage exporter initialized", {
+      strategy: this.#resolvedStrategy,
+      source: this.#config.strategy !== "auto" ? "user" : "auto",
+      storageAdapter: storage.constructor.name,
+      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;
   }
-};
-
-// src/spans/base.ts
-function isSpanInternal(spanType, flags) {
-  if (flags === void 0 || flags === InternalSpans.NONE) {
+  /**
+   * Checks if buffer should be flushed based on size or time triggers
+   */
+  shouldFlush() {
+    if (this.buffer.totalSize >= this.#config.maxBufferSize) {
+      return true;
+    }
+    if (this.buffer.totalSize >= this.#config.maxBatchSize) {
+      return true;
+    }
+    if (this.buffer.firstEventTime && this.buffer.totalSize > 0) {
+      const elapsed = Date.now() - this.buffer.firstEventTime.getTime();
+      if (elapsed >= this.#config.maxBatchWaitMs) {
+        return true;
+      }
+    }
     return false;
   }
-  switch (spanType) {
-    // Workflow-related spans
-    case AISpanType.WORKFLOW_RUN:
-    case AISpanType.WORKFLOW_STEP:
-    case AISpanType.WORKFLOW_CONDITIONAL:
-    case AISpanType.WORKFLOW_CONDITIONAL_EVAL:
-    case AISpanType.WORKFLOW_PARALLEL:
-    case AISpanType.WORKFLOW_LOOP:
-    case AISpanType.WORKFLOW_SLEEP:
-    case AISpanType.WORKFLOW_WAIT_EVENT:
-      return (flags & InternalSpans.WORKFLOW) !== 0;
-    // Agent-related spans
-    case AISpanType.AGENT_RUN:
-      return (flags & InternalSpans.AGENT) !== 0;
-    // Tool-related spans
-    case AISpanType.TOOL_CALL:
-    case AISpanType.MCP_TOOL_CALL:
-      return (flags & InternalSpans.TOOL) !== 0;
-    // Model-related spans
-    case AISpanType.MODEL_GENERATION:
-    case AISpanType.MODEL_STEP:
-    case AISpanType.MODEL_CHUNK:
-      return (flags & InternalSpans.MODEL) !== 0;
-    // Default: never internal
-    default:
-      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);
+    }
   }
-}
-var BaseAISpan = class {
-  name;
-  type;
-  attributes;
-  parent;
-  startTime;
-  endTime;
-  isEvent;
-  isInternal;
-  aiTracing;
-  input;
-  output;
-  errorInfo;
-  metadata;
-  traceState;
-  /** Parent span ID (for root spans that are children of external spans) */
-  parentSpanId;
-  constructor(options, aiTracing) {
-    this.name = options.name;
-    this.type = options.type;
-    this.attributes = deepClean(options.attributes) || {};
-    this.metadata = deepClean(options.metadata);
-    this.parent = options.parent;
-    this.startTime = /* @__PURE__ */ new Date();
-    this.aiTracing = aiTracing;
-    this.isEvent = options.isEvent ?? false;
-    this.isInternal = isSpanInternal(this.type, options.tracingPolicy?.internal);
-    this.traceState = options.traceState;
-    if (this.isEvent) {
-      this.output = deepClean(options.output);
-    } else {
-      this.input = deepClean(options.input);
+  /**
+   * Schedules a flush using setTimeout
+   */
+  scheduleFlush() {
+    if (this.#flushTimer) {
+      clearTimeout(this.#flushTimer);
+    }
+    this.#flushTimer = setTimeout(() => {
+      this.flush().catch((error) => {
+        this.logger.error("Scheduled flush failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }, this.#config.maxBatchWaitMs);
+  }
+  /**
+   * Serializes span attributes to storage record format
+   * Handles all Span types and their specific attributes
+   */
+  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 (error) {
+      this.logger.warn("Failed to serialize span attributes, storing as null", {
+        spanId: span.id,
+        spanType: span.type,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
     }
   }
-  createChildSpan(options) {
-    return this.aiTracing.startSpan({ ...options, parent: this, isEvent: false });
+  buildCreateRecord(span) {
+    return {
+      traceId: span.traceId,
+      spanId: span.id,
+      parentSpanId: span.parentSpanId ?? null,
+      name: span.name,
+      scope: null,
+      spanType: span.type,
+      attributes: this.serializeAttributes(span),
+      metadata: span.metadata ?? null,
+      links: null,
+      startedAt: span.startTime,
+      endedAt: span.endTime ?? null,
+      input: span.input,
+      output: span.output,
+      error: span.errorInfo,
+      isEvent: span.isEvent
+    };
   }
-  createEventSpan(options) {
-    return this.aiTracing.startSpan({ ...options, parent: this, isEvent: true });
+  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
+    };
   }
   /**
-   * Create a ModelSpanTracker for this span (only works if this is a MODEL_GENERATION span)
-   * Returns undefined for non-MODEL_GENERATION spans
+   * Handles realtime strategy - processes each event immediately
    */
-  createTracker() {
-    if (this.type !== AISpanType.MODEL_GENERATION) {
-      return void 0;
+  async handleRealtimeEvent(event, storage) {
+    const span = event.exportedSpan;
+    const spanKey = this.buildSpanKey(span.traceId, span.id);
+    if (span.isEvent) {
+      if (event.type === TracingEventType.SPAN_ENDED) {
+        await storage.createSpan(this.buildCreateRecord(event.exportedSpan));
+      } else {
+        this.logger.warn(`Tracing event type not implemented for event spans: ${event.type}`);
+      }
+    } else {
+      switch (event.type) {
+        case TracingEventType.SPAN_STARTED:
+          await storage.createSpan(this.buildCreateRecord(event.exportedSpan));
+          this.allCreatedSpans.add(spanKey);
+          break;
+        case TracingEventType.SPAN_UPDATED:
+          await storage.updateSpan({
+            traceId: span.traceId,
+            spanId: span.id,
+            updates: this.buildUpdateRecord(span)
+          });
+          break;
+        case TracingEventType.SPAN_ENDED:
+          await storage.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}`);
+      }
     }
-    return new ModelSpanTracker(this);
-  }
-  /** Returns `TRUE` if the span is the root span of a trace */
-  get isRootSpan() {
-    return !this.parent;
   }
-  /** Get the closest parent spanId that isn't an internal span */
-  getParentSpanId(includeInternalSpans) {
-    if (!this.parent) {
-      return this.parentSpanId;
+  /**
+   * Handles batch-with-updates strategy - buffers events and processes in batches
+   */
+  handleBatchWithUpdatesEvent(event) {
+    this.addToBuffer(event);
+    if (this.shouldFlush()) {
+      this.flush().catch((error) => {
+        this.logger.error("Batch flush failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    } else if (this.buffer.totalSize === 1) {
+      this.scheduleFlush();
     }
-    if (includeInternalSpans) return this.parent.id;
-    if (this.parent.isInternal) return this.parent.getParentSpanId(includeInternalSpans);
-    return this.parent.id;
   }
-  /** Find the closest parent span of a specific type by walking up the parent chain */
-  findParent(spanType) {
-    let current = this.parent;
-    while (current) {
-      if (current.type === spanType) {
-        return current;
+  /**
+   * 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.flush().catch((error) => {
+          this.logger.error("Batch flush failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      } else if (this.buffer.totalSize === 1) {
+        this.scheduleFlush();
       }
-      current = current.parent;
     }
-    return void 0;
-  }
-  /** Returns a lightweight span ready for export */
-  exportSpan(includeInternalSpans) {
-    return {
-      id: this.id,
-      traceId: this.traceId,
-      name: this.name,
-      type: this.type,
-      attributes: this.attributes,
-      metadata: this.metadata,
-      startTime: this.startTime,
-      endTime: this.endTime,
-      input: this.input,
-      output: this.output,
-      errorInfo: this.errorInfo,
-      isEvent: this.isEvent,
-      isRootSpan: this.isRootSpan,
-      parentSpanId: this.getParentSpanId(includeInternalSpans)
-    };
-  }
-  get externalTraceId() {
-    return this.isValid ? this.traceId : void 0;
   }
-};
-var DEFAULT_KEYS_TO_STRIP = /* @__PURE__ */ new Set([
-  "logger",
-  "experimental_providerMetadata",
-  "providerMetadata",
-  "steps",
-  "tracingContext"
-]);
-function deepClean(value, options = {}, _seen = /* @__PURE__ */ new WeakSet(), _depth = 0) {
-  const { keysToStrip = DEFAULT_KEYS_TO_STRIP, maxDepth = 10 } = options;
-  if (_depth > maxDepth) {
-    return "[MaxDepth]";
+  /**
+   * Calculates retry delay using exponential backoff
+   */
+  calculateRetryDelay(attempt) {
+    return this.#config.retryDelayMs * Math.pow(2, attempt);
   }
-  if (value === null || typeof value !== "object") {
-    try {
-      JSON.stringify(value);
-      return value;
-    } catch (error) {
-      return `[${error instanceof Error ? error.message : String(error)}]`;
+  /**
+   * Flushes the current buffer to storage with retry logic
+   */
+  async flush() {
+    if (!this.#storage) {
+      this.logger.debug("Cannot flush traces. Mastra storage is not initialized");
+      return;
     }
-  }
-  if (_seen.has(value)) {
-    return "[Circular]";
-  }
-  _seen.add(value);
-  if (Array.isArray(value)) {
-    return value.map((item) => deepClean(item, options, _seen, _depth + 1));
-  }
-  const cleaned = {};
-  for (const [key, val] of Object.entries(value)) {
-    if (keysToStrip.has(key)) {
-      continue;
+    if (this.#flushTimer) {
+      clearTimeout(this.#flushTimer);
+      this.#flushTimer = null;
     }
-    try {
-      cleaned[key] = deepClean(val, options, _seen, _depth + 1);
-    } catch (error) {
-      cleaned[key] = `[${error instanceof Error ? error.message : String(error)}]`;
+    if (this.buffer.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.#storage, bufferCopy, 0);
+    const elapsed = Date.now() - startTime;
+    this.logger.debug("Batch flushed", {
+      strategy: this.#resolvedStrategy,
+      batchSize: bufferCopy.totalSize,
+      flushReason,
+      durationMs: elapsed,
+      outOfOrderCount: bufferCopy.outOfOrderCount > 0 ? bufferCopy.outOfOrderCount : void 0
+    });
   }
-  return cleaned;
-}
-var DefaultAISpan = class extends BaseAISpan {
-  id;
-  traceId;
-  constructor(options, aiTracing) {
-    super(options, aiTracing);
-    this.id = generateSpanId();
-    if (options.parent) {
-      this.traceId = options.parent.traceId;
-    } else if (options.traceId) {
-      if (isValidTraceId(options.traceId)) {
-        this.traceId = options.traceId;
-      } else {
-        console.error(
-          `[Mastra Tracing] Invalid traceId: must be 1-32 hexadecimal characters, got "${options.traceId}". Generating new trace ID.`
-        );
-        this.traceId = generateTraceId();
+  /**
+   * Attempts to flush with exponential backoff retry logic
+   */
+  async flushWithRetries(storage, buffer, attempt) {
+    try {
+      if (this.#resolvedStrategy === "batch-with-updates") {
+        if (buffer.creates.length > 0) {
+          await storage.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 storage.batchUpdateSpans({ records: sortedUpdates });
+        }
+      } else if (this.#resolvedStrategy === "insert-only") {
+        if (buffer.insertOnly.length > 0) {
+          await storage.batchCreateSpans({ records: buffer.insertOnly });
+        }
       }
-    } else {
-      this.traceId = generateTraceId();
-    }
-    if (!options.parent && options.parentSpanId) {
-      if (isValidSpanId(options.parentSpanId)) {
-        this.parentSpanId = options.parentSpanId;
+      for (const spanKey of buffer.completedSpans) {
+        this.allCreatedSpans.delete(spanKey);
+      }
+    } catch (error) {
+      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: error instanceof Error ? error.message : String(error)
+        });
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        return this.flushWithRetries(storage, buffer, attempt + 1);
       } else {
-        console.error(
-          `[Mastra Tracing] Invalid parentSpanId: must be 1-16 hexadecimal characters, got "${options.parentSpanId}". Ignoring parent span ID.`
-        );
+        this.logger.error("Batch flush failed after all retries, dropping batch", {
+          finalAttempt: attempt + 1,
+          maxRetries: this.#config.maxRetries,
+          droppedBatchSize: buffer.totalSize,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        for (const spanKey of buffer.completedSpans) {
+          this.allCreatedSpans.delete(spanKey);
+        }
       }
     }
   }
-  end(options) {
-    if (this.isEvent) {
-      return;
-    }
-    this.endTime = /* @__PURE__ */ new Date();
-    if (options?.output !== void 0) {
-      this.output = deepClean(options.output);
-    }
-    if (options?.attributes) {
-      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
-    }
-    if (options?.metadata) {
-      this.metadata = { ...this.metadata, ...deepClean(options.metadata) };
-    }
-  }
-  error(options) {
-    if (this.isEvent) {
+  async _exportTracingEvent(event) {
+    if (!this.#storage) {
+      this.logger.debug("Cannot store traces. Mastra storage is not initialized");
       return;
     }
-    const { error, endSpan = true, attributes, metadata } = options;
-    this.errorInfo = error instanceof MastraError ? {
-      id: error.id,
-      details: error.details,
-      category: error.category,
-      domain: error.domain,
-      message: error.message
-    } : {
-      message: error.message
-    };
-    if (attributes) {
-      this.attributes = { ...this.attributes, ...deepClean(attributes) };
-    }
-    if (metadata) {
-      this.metadata = { ...this.metadata, ...deepClean(metadata) };
+    if (!this.#strategyInitialized) {
+      this.initializeStrategy(this.#storage);
     }
-    if (endSpan) {
-      this.end();
-    } else {
-      this.update({});
+    switch (this.#resolvedStrategy) {
+      case "realtime":
+        await this.handleRealtimeEvent(event, this.#storage);
+        break;
+      case "batch-with-updates":
+        this.handleBatchWithUpdatesEvent(event);
+        break;
+      case "insert-only":
+        this.handleInsertOnlyEvent(event);
+        break;
     }
   }
-  update(options) {
-    if (this.isEvent) {
-      return;
-    }
-    if (options.input !== void 0) {
-      this.input = deepClean(options.input);
-    }
-    if (options.output !== void 0) {
-      this.output = deepClean(options.output);
-    }
-    if (options.attributes) {
-      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
+  async shutdown() {
+    if (this.#flushTimer) {
+      clearTimeout(this.#flushTimer);
+      this.#flushTimer = null;
     }
-    if (options.metadata) {
-      this.metadata = { ...this.metadata, ...deepClean(options.metadata) };
+    if (this.buffer.totalSize > 0) {
+      this.logger.info("Flushing remaining events on shutdown", {
+        remainingEvents: this.buffer.totalSize
+      });
+      try {
+        await this.flush();
+      } catch (error) {
+        this.logger.error("Failed to flush remaining events during shutdown", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
     }
-  }
-  get isValid() {
-    return true;
-  }
-  async export() {
-    return JSON.stringify({
-      spanId: this.id,
-      traceId: this.traceId,
-      startTime: this.startTime,
-      endTime: this.endTime,
-      attributes: this.attributes,
-      metadata: this.metadata
-    });
+    this.logger.info("DefaultExporter shutdown complete");
   }
 };
-function generateSpanId() {
-  const bytes = new Uint8Array(8);
-  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-    crypto.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < 8; i++) {
-      bytes[i] = Math.floor(Math.random() * 256);
-    }
-  }
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function generateTraceId() {
-  const bytes = new Uint8Array(16);
-  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-    crypto.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < 16; i++) {
-      bytes[i] = Math.floor(Math.random() * 256);
-    }
-  }
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function isValidTraceId(traceId) {
-  return /^[0-9a-f]{1,32}$/i.test(traceId);
-}
-function isValidSpanId(spanId) {
-  return /^[0-9a-f]{1,16}$/i.test(spanId);
-}
-
-// src/spans/no-op.ts
-var NoOpAISpan = class extends BaseAISpan {
-  id;
-  traceId;
-  constructor(options, aiTracing) {
-    super(options, aiTracing);
-    this.id = "no-op";
-    this.traceId = "no-op-trace";
+var ModelSpanTracker = class {
+  #modelSpan;
+  #currentStepSpan;
+  #currentChunkSpan;
+  #accumulator = {};
+  #stepIndex = 0;
+  #chunkSequence = 0;
+  constructor(modelSpan) {
+    this.#modelSpan = modelSpan;
   }
-  end(_options) {
+  /**
+   * Get the tracing context for creating child spans.
+   * Returns the current step span if active, otherwise the model span.
+   */
+  getTracingContext() {
+    return {
+      currentSpan: this.#currentStepSpan ?? this.#modelSpan
+    };
   }
-  error(_options) {
+  /**
+   * Report an error on the generation span
+   */
+  reportGenerationError(options) {
+    this.#modelSpan?.error(options);
   }
-  update(_options) {
+  /**
+   * End the generation span
+   */
+  endGeneration(options) {
+    this.#modelSpan?.end(options);
   }
-  get isValid() {
-    return false;
+  /**
+   * Update the generation span
+   */
+  updateGeneration(options) {
+    this.#modelSpan?.update(options);
   }
-};
-
-// src/tracers/base.ts
-var BaseAITracing = class extends MastraBase {
-  config;
-  constructor(config) {
-    super({ component: RegisteredLogger.AI_TRACING, name: config.serviceName });
-    this.config = {
-      serviceName: config.serviceName,
-      name: config.name,
-      sampling: config.sampling ?? { type: SamplingStrategyType.ALWAYS },
-      exporters: config.exporters ?? [],
-      processors: config.processors ?? [],
-      includeInternalSpans: config.includeInternalSpans ?? false,
-      requestContextKeys: config.requestContextKeys ?? []
-    };
+  /**
+   * Start a new Model execution step
+   */
+  #startStepSpan(payload) {
+    this.#currentStepSpan = this.#modelSpan?.createChildSpan({
+      name: `step: ${this.#stepIndex}`,
+      type: SpanType.MODEL_STEP,
+      attributes: {
+        stepIndex: this.#stepIndex,
+        ...payload?.messageId ? { messageId: payload.messageId } : {},
+        ...payload?.warnings?.length ? { warnings: payload.warnings } : {}
+      },
+      input: payload?.request
+    });
+    this.#chunkSequence = 0;
   }
   /**
-   * Override setLogger to add AI tracing specific initialization log
-   * and propagate logger to exporters
+   * End the current Model execution step with token usage, finish reason, output, and metadata
    */
-  __setLogger(logger) {
-    super.__setLogger(logger);
-    this.exporters.forEach((exporter) => {
-      if (typeof exporter.__setLogger === "function") {
-        exporter.__setLogger(logger);
+  #endStepSpan(payload) {
+    if (!this.#currentStepSpan) return;
+    const output = payload.output;
+    const { usage, ...otherOutput } = output;
+    const stepResult = payload.stepResult;
+    const metadata = payload.metadata;
+    const cleanMetadata = metadata ? { ...metadata } : void 0;
+    if (cleanMetadata?.request) {
+      delete cleanMetadata.request;
+    }
+    this.#currentStepSpan.end({
+      output: otherOutput,
+      attributes: {
+        usage,
+        isContinued: stepResult.isContinued,
+        finishReason: stepResult.reason,
+        warnings: stepResult.warnings
+      },
+      metadata: {
+        ...cleanMetadata
       }
     });
-    this.logger.debug(
-      `[AI Tracing] Initialized [service=${this.config.serviceName}] [instance=${this.config.name}] [sampling=${this.config.sampling.type}]`
-    );
-  }
-  // ============================================================================
-  // Protected getters for clean config access
-  // ============================================================================
-  get exporters() {
-    return this.config.exporters || [];
-  }
-  get processors() {
-    return this.config.processors || [];
+    this.#currentStepSpan = void 0;
+    this.#stepIndex++;
   }
-  // ============================================================================
-  // Public API - Single type-safe span creation method
-  // ============================================================================
   /**
-   * Start a new span of a specific AISpanType
+   * Create a new chunk span (for multi-part chunks like text-start/delta/end)
    */
-  startSpan(options) {
-    const { customSamplerOptions, requestContext, metadata, tracingOptions, ...rest } = options;
-    if (!this.shouldSample(customSamplerOptions)) {
-      return new NoOpAISpan({ ...rest, metadata }, this);
-    }
-    let traceState;
-    if (options.parent) {
-      traceState = options.parent.traceState;
-    } else {
-      traceState = this.computeTraceState(tracingOptions);
+  #startChunkSpan(chunkType, initialData) {
+    if (!this.#currentStepSpan) {
+      this.#startStepSpan();
     }
-    const enrichedMetadata = this.extractMetadataFromRequestContext(requestContext, metadata, traceState);
-    const span = this.createSpan({
-      ...rest,
-      metadata: enrichedMetadata,
-      traceState
+    this.#currentChunkSpan = this.#currentStepSpan?.createChildSpan({
+      name: `chunk: '${chunkType}'`,
+      type: SpanType.MODEL_CHUNK,
+      attributes: {
+        chunkType,
+        sequenceNumber: this.#chunkSequence
+      }
     });
-    if (span.isEvent) {
-      this.emitSpanEnded(span);
+    this.#accumulator = initialData || {};
+  }
+  /**
+   * Append string content to a specific field in the accumulator
+   */
+  #appendToAccumulator(field, text) {
+    if (this.#accumulator[field] === void 0) {
+      this.#accumulator[field] = text;
     } else {
-      this.wireSpanLifecycle(span);
-      this.emitSpanStarted(span);
+      this.#accumulator[field] += text;
     }
-    return span;
   }
-  // ============================================================================
-  // Configuration Management
-  // ============================================================================
   /**
-   * Get current configuration
+   * End the current chunk span.
+   * Safe to call multiple times - will no-op if span already ended.
    */
-  getConfig() {
-    return { ...this.config };
+  #endChunkSpan(output) {
+    if (!this.#currentChunkSpan) return;
+    this.#currentChunkSpan.end({
+      output: output !== void 0 ? output : this.#accumulator
+    });
+    this.#currentChunkSpan = void 0;
+    this.#accumulator = {};
+    this.#chunkSequence++;
   }
-  // ============================================================================
-  // Plugin Access
-  // ============================================================================
   /**
-   * Get all exporters
+   * Create an event span (for single chunks like tool-call)
    */
-  getExporters() {
-    return [...this.exporters];
+  #createEventSpan(chunkType, output) {
+    if (!this.#currentStepSpan) {
+      this.#startStepSpan();
+    }
+    const span = this.#currentStepSpan?.createEventSpan({
+      name: `chunk: '${chunkType}'`,
+      type: SpanType.MODEL_CHUNK,
+      attributes: {
+        chunkType,
+        sequenceNumber: this.#chunkSequence
+      },
+      output
+    });
+    if (span) {
+      this.#chunkSequence++;
+    }
   }
   /**
-   * Get all processors
+   * Check if there is currently an active chunk span
    */
-  getProcessors() {
-    return [...this.processors];
+  #hasActiveChunkSpan() {
+    return !!this.#currentChunkSpan;
   }
   /**
-   * Get the logger instance (for exporters and other components)
+   * Get the current accumulator value
    */
-  getLogger() {
-    return this.logger;
+  #getAccumulator() {
+    return this.#accumulator;
   }
-  // ============================================================================
-  // Span Lifecycle Management
-  // ============================================================================
   /**
-   * Automatically wires up AI tracing lifecycle events for any span
-   * This ensures all spans emit events regardless of implementation
+   * Handle text chunk spans (text-start/delta/end)
    */
-  wireSpanLifecycle(span) {
-    if (!this.config.includeInternalSpans && span.isInternal) {
-      return;
-    }
-    const originalEnd = span.end.bind(span);
-    const originalUpdate = span.update.bind(span);
-    span.end = (options) => {
-      if (span.isEvent) {
-        this.logger.warn(`End event is not available on event spans`);
-        return;
-      }
-      originalEnd(options);
-      this.emitSpanEnded(span);
-    };
-    span.update = (options) => {
-      if (span.isEvent) {
-        this.logger.warn(`Update() is not available on event spans`);
-        return;
+  #handleTextChunk(chunk) {
+    switch (chunk.type) {
+      case "text-start":
+        this.#startChunkSpan("text");
+        break;
+      case "text-delta":
+        this.#appendToAccumulator("text", chunk.payload.text);
+        break;
+      case "text-end": {
+        this.#endChunkSpan();
+        break;
       }
-      originalUpdate(options);
-      this.emitSpanUpdated(span);
-    };
+    }
   }
-  // ============================================================================
-  // Utility Methods
-  // ============================================================================
   /**
-   * Check if an AI trace should be sampled
+   * Handle reasoning chunk spans (reasoning-start/delta/end)
    */
-  shouldSample(options) {
-    const { sampling } = this.config;
-    switch (sampling.type) {
-      case SamplingStrategyType.ALWAYS:
-        return true;
-      case SamplingStrategyType.NEVER:
-        return false;
-      case SamplingStrategyType.RATIO:
-        if (sampling.probability === void 0 || sampling.probability < 0 || sampling.probability > 1) {
-          this.logger.warn(
-            `Invalid sampling probability: ${sampling.probability}. Expected value between 0 and 1. Defaulting to no sampling.`
-          );
-          return false;
-        }
-        return Math.random() < sampling.probability;
-      case SamplingStrategyType.CUSTOM:
-        return sampling.sampler(options);
-      default:
-        throw new Error(`Sampling strategy type not implemented: ${sampling.type}`);
+  #handleReasoningChunk(chunk) {
+    switch (chunk.type) {
+      case "reasoning-start":
+        this.#startChunkSpan("reasoning");
+        break;
+      case "reasoning-delta":
+        this.#appendToAccumulator("text", chunk.payload.text);
+        break;
+      case "reasoning-end": {
+        this.#endChunkSpan();
+        break;
+      }
     }
   }
   /**
-   * Compute TraceState for a new trace based on configured and per-request keys
+   * Handle tool call chunk spans (tool-call-input-streaming-start/delta/end, tool-call)
    */
-  computeTraceState(tracingOptions) {
-    const configuredKeys = this.config.requestContextKeys ?? [];
-    const additionalKeys = tracingOptions?.requestContextKeys ?? [];
-    const allKeys = [...configuredKeys, ...additionalKeys];
-    if (allKeys.length === 0) {
-      return void 0;
+  #handleToolCallChunk(chunk) {
+    switch (chunk.type) {
+      case "tool-call-input-streaming-start":
+        this.#startChunkSpan("tool-call", {
+          toolName: chunk.payload.toolName,
+          toolCallId: chunk.payload.toolCallId
+        });
+        break;
+      case "tool-call-delta":
+        this.#appendToAccumulator("toolInput", chunk.payload.argsTextDelta);
+        break;
+      case "tool-call-input-streaming-end":
+      case "tool-call": {
+        const acc = this.#getAccumulator();
+        let toolInput;
+        try {
+          toolInput = acc.toolInput ? JSON.parse(acc.toolInput) : {};
+        } catch {
+          toolInput = acc.toolInput;
+        }
+        this.#endChunkSpan({
+          toolName: acc.toolName,
+          toolCallId: acc.toolCallId,
+          toolInput
+        });
+        break;
+      }
     }
-    return {
-      requestContextKeys: allKeys
-    };
   }
   /**
-   * Extract metadata from RequestContext using TraceState
+   * Handle object chunk spans (object, object-result)
    */
-  extractMetadataFromRequestContext(requestContext, explicitMetadata, traceState) {
-    if (!requestContext || !traceState || traceState.requestContextKeys.length === 0) {
-      return explicitMetadata;
-    }
-    const extracted = this.extractKeys(requestContext, traceState.requestContextKeys);
-    if (Object.keys(extracted).length === 0 && !explicitMetadata) {
-      return void 0;
+  #handleObjectChunk(chunk) {
+    switch (chunk.type) {
+      case "object":
+        if (!this.#hasActiveChunkSpan()) {
+          this.#startChunkSpan("object");
+        }
+        break;
+      case "object-result":
+        this.#endChunkSpan(chunk.object);
+        break;
     }
-    return {
-      ...extracted,
-      ...explicitMetadata
-      // Explicit metadata always wins
-    };
   }
   /**
-   * Extract specific keys from RequestContext
+   * Wraps a stream with model tracing transform to track MODEL_STEP and MODEL_CHUNK spans.
+   *
+   * This should be added to the stream pipeline to automatically
+   * create MODEL_STEP and MODEL_CHUNK spans for each semantic unit in the stream.
    */
-  extractKeys(requestContext, keys) {
-    const result = {};
-    for (const key of keys) {
-      const parts = key.split(".");
-      const rootKey = parts[0];
-      const value = requestContext.get(rootKey);
-      if (value !== void 0) {
-        if (parts.length > 1) {
-          const nestedPath = parts.slice(1).join(".");
-          const nestedValue = getNestedValue(value, nestedPath);
-          if (nestedValue !== void 0) {
-            setNestedValue(result, key, nestedValue);
+  wrapStream(stream) {
+    return stream.pipeThrough(
+      new TransformStream({
+        transform: (chunk, controller) => {
+          controller.enqueue(chunk);
+          switch (chunk.type) {
+            case "text-start":
+            case "text-delta":
+            case "text-end":
+              this.#handleTextChunk(chunk);
+              break;
+            case "tool-call-input-streaming-start":
+            case "tool-call-delta":
+            case "tool-call-input-streaming-end":
+            case "tool-call":
+              this.#handleToolCallChunk(chunk);
+              break;
+            case "reasoning-start":
+            case "reasoning-delta":
+            case "reasoning-end":
+              this.#handleReasoningChunk(chunk);
+              break;
+            case "object":
+            case "object-result":
+              this.#handleObjectChunk(chunk);
+              break;
+            case "step-start":
+              this.#startStepSpan(chunk.payload);
+              break;
+            case "step-finish":
+              this.#endStepSpan(chunk.payload);
+              break;
+            case "raw":
+            // Skip raw chunks as they're redundant
+            case "start":
+            case "finish":
+              break;
+            // Default: auto-create event span for all other chunk types
+            default: {
+              let outputPayload = chunk.payload;
+              if (outputPayload && typeof outputPayload === "object" && "data" in outputPayload) {
+                const typedPayload = outputPayload;
+                outputPayload = { ...typedPayload };
+                if (typedPayload.data) {
+                  outputPayload.size = typeof typedPayload.data === "string" ? typedPayload.data.length : typedPayload.data instanceof Uint8Array ? typedPayload.data.length : void 0;
+                  delete outputPayload.data;
+                }
+              }
+              this.#createEventSpan(chunk.type, outputPayload);
+              break;
+            }
           }
-        } else {
-          setNestedValue(result, key, value);
         }
-      }
-    }
-    return result;
+      })
+    );
   }
-  /**
-   * Process a span through all processors
-   */
-  processSpan(span) {
-    for (const processor of this.processors) {
-      if (!span) {
-        break;
-      }
-      try {
-        span = processor.process(span);
-      } catch (error) {
-        this.logger.error(`[AI Tracing] Processor error [name=${processor.name}]`, error);
-      }
-    }
-    return span;
+};
+
+// src/spans/base.ts
+function isSpanInternal(spanType, flags) {
+  if (flags === void 0 || flags === InternalSpans.NONE) {
+    return false;
   }
-  // ============================================================================
-  // Event-driven Export Methods
-  // ============================================================================
-  getSpanForExport(span) {
-    if (!span.isValid) return void 0;
-    if (span.isInternal && !this.config.includeInternalSpans) return void 0;
-    const processedSpan = this.processSpan(span);
-    return processedSpan?.exportSpan(this.config.includeInternalSpans);
+  switch (spanType) {
+    // Workflow-related spans
+    case SpanType.WORKFLOW_RUN:
+    case SpanType.WORKFLOW_STEP:
+    case SpanType.WORKFLOW_CONDITIONAL:
+    case SpanType.WORKFLOW_CONDITIONAL_EVAL:
+    case SpanType.WORKFLOW_PARALLEL:
+    case SpanType.WORKFLOW_LOOP:
+    case SpanType.WORKFLOW_SLEEP:
+    case SpanType.WORKFLOW_WAIT_EVENT:
+      return (flags & InternalSpans.WORKFLOW) !== 0;
+    // Agent-related spans
+    case SpanType.AGENT_RUN:
+      return (flags & InternalSpans.AGENT) !== 0;
+    // Tool-related spans
+    case SpanType.TOOL_CALL:
+    case SpanType.MCP_TOOL_CALL:
+      return (flags & InternalSpans.TOOL) !== 0;
+    // Model-related spans
+    case SpanType.MODEL_GENERATION:
+    case SpanType.MODEL_STEP:
+    case SpanType.MODEL_CHUNK:
+      return (flags & InternalSpans.MODEL) !== 0;
+    // Default: never internal
+    default:
+      return false;
   }
-  /**
-   * Emit a span started event
-   */
-  emitSpanStarted(span) {
-    const exportedSpan = this.getSpanForExport(span);
-    if (exportedSpan) {
-      this.exportEvent({ type: AITracingEventType.SPAN_STARTED, exportedSpan }).catch((error) => {
-        this.logger.error("[AI Tracing] Failed to export span_started event", error);
-      });
+}
+var BaseSpan = class {
+  name;
+  type;
+  attributes;
+  parent;
+  startTime;
+  endTime;
+  isEvent;
+  isInternal;
+  observabilityInstance;
+  input;
+  output;
+  errorInfo;
+  metadata;
+  traceState;
+  /** Parent span ID (for root spans that are children of external spans) */
+  parentSpanId;
+  constructor(options, observabilityInstance) {
+    this.name = options.name;
+    this.type = options.type;
+    this.attributes = deepClean(options.attributes) || {};
+    this.metadata = deepClean(options.metadata);
+    this.parent = options.parent;
+    this.startTime = /* @__PURE__ */ new Date();
+    this.observabilityInstance = observabilityInstance;
+    this.isEvent = options.isEvent ?? false;
+    this.isInternal = isSpanInternal(this.type, options.tracingPolicy?.internal);
+    this.traceState = options.traceState;
+    if (this.isEvent) {
+      this.output = deepClean(options.output);
+    } else {
+      this.input = deepClean(options.input);
     }
   }
+  createChildSpan(options) {
+    return this.observabilityInstance.startSpan({ ...options, parent: this, isEvent: false });
+  }
+  createEventSpan(options) {
+    return this.observabilityInstance.startSpan({ ...options, parent: this, isEvent: true });
+  }
   /**
-   * Emit a span ended event (called automatically when spans end)
+   * Create a ModelSpanTracker for this span (only works if this is a MODEL_GENERATION span)
+   * Returns undefined for non-MODEL_GENERATION spans
    */
-  emitSpanEnded(span) {
-    const exportedSpan = this.getSpanForExport(span);
-    if (exportedSpan) {
-      this.exportEvent({ type: AITracingEventType.SPAN_ENDED, exportedSpan }).catch((error) => {
-        this.logger.error("[AI Tracing] Failed to export span_ended event", error);
-      });
+  createTracker() {
+    if (this.type !== SpanType.MODEL_GENERATION) {
+      return void 0;
     }
+    return new ModelSpanTracker(this);
   }
-  /**
-   * Emit a span updated event
-   */
-  emitSpanUpdated(span) {
-    const exportedSpan = this.getSpanForExport(span);
-    if (exportedSpan) {
-      this.exportEvent({ type: AITracingEventType.SPAN_UPDATED, exportedSpan }).catch((error) => {
-        this.logger.error("[AI Tracing] Failed to export span_updated event", error);
-      });
+  /** Returns `TRUE` if the span is the root span of a trace */
+  get isRootSpan() {
+    return !this.parent;
+  }
+  /** Get the closest parent spanId that isn't an internal span */
+  getParentSpanId(includeInternalSpans) {
+    if (!this.parent) {
+      return this.parentSpanId;
     }
+    if (includeInternalSpans) return this.parent.id;
+    if (this.parent.isInternal) return this.parent.getParentSpanId(includeInternalSpans);
+    return this.parent.id;
   }
-  /**
-   * Export tracing event through all exporters (realtime mode)
-   */
-  async exportEvent(event) {
-    const exportPromises = this.exporters.map(async (exporter) => {
-      try {
-        if (exporter.exportEvent) {
-          await exporter.exportEvent(event);
-          this.logger.debug(`[AI Tracing] Event exported [exporter=${exporter.name}] [type=${event.type}]`);
-        }
-      } catch (error) {
-        this.logger.error(`[AI Tracing] Export error [exporter=${exporter.name}]`, error);
+  /** Find the closest parent span of a specific type by walking up the parent chain */
+  findParent(spanType) {
+    let current = this.parent;
+    while (current) {
+      if (current.type === spanType) {
+        return current;
       }
-    });
-    await Promise.allSettled(exportPromises);
+      current = current.parent;
+    }
+    return void 0;
   }
-  // ============================================================================
-  // Lifecycle Management
-  // ============================================================================
-  /**
-   * Initialize AI tracing (called by Mastra during component registration)
-   */
-  init() {
-    this.logger.debug(`[AI Tracing] Initialization started [name=${this.name}]`);
-    this.logger.info(`[AI Tracing] Initialized successfully [name=${this.name}]`);
+  /** Returns a lightweight span ready for export */
+  exportSpan(includeInternalSpans) {
+    return {
+      id: this.id,
+      traceId: this.traceId,
+      name: this.name,
+      type: this.type,
+      attributes: this.attributes,
+      metadata: this.metadata,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      input: this.input,
+      output: this.output,
+      errorInfo: this.errorInfo,
+      isEvent: this.isEvent,
+      isRootSpan: this.isRootSpan,
+      parentSpanId: this.getParentSpanId(includeInternalSpans)
+    };
   }
-  /**
-   * Shutdown AI tracing and clean up resources
-   */
-  async shutdown() {
-    this.logger.debug(`[AI Tracing] Shutdown started [name=${this.name}]`);
-    const shutdownPromises = [...this.exporters.map((e) => e.shutdown()), ...this.processors.map((p) => p.shutdown())];
-    await Promise.allSettled(shutdownPromises);
-    this.logger.info(`[AI Tracing] Shutdown completed [name=${this.name}]`);
+  get externalTraceId() {
+    return this.isValid ? this.traceId : void 0;
   }
 };
-
-// src/tracers/default.ts
-var DefaultAITracing = class extends BaseAITracing {
-  constructor(config) {
-    super(config);
+var DEFAULT_KEYS_TO_STRIP = /* @__PURE__ */ new Set([
+  "logger",
+  "experimental_providerMetadata",
+  "providerMetadata",
+  "steps",
+  "tracingContext"
+]);
+function deepClean(value, options = {}, _seen = /* @__PURE__ */ new WeakSet(), _depth = 0) {
+  const { keysToStrip = DEFAULT_KEYS_TO_STRIP, maxDepth = 10 } = options;
+  if (_depth > maxDepth) {
+    return "[MaxDepth]";
   }
-  createSpan(options) {
-    return new DefaultAISpan(options, this);
+  if (value === null || typeof value !== "object") {
+    try {
+      JSON.stringify(value);
+      return value;
+    } catch (error) {
+      return `[${error instanceof Error ? error.message : String(error)}]`;
+    }
   }
-};
-var BaseExporter = class {
-  /** Mastra logger instance */
-  logger;
-  /** Whether this exporter is disabled */
-  isDisabled = false;
-  /**
-   * Initialize the base exporter with logger
-   */
-  constructor(config = {}) {
-    const logLevel = this.resolveLogLevel(config.logLevel);
-    this.logger = config.logger ?? new ConsoleLogger({ level: logLevel, name: this.constructor.name });
+  if (_seen.has(value)) {
+    return "[Circular]";
   }
-  /**
-   * Set the logger for the exporter (called by Mastra/AITracing during initialization)
-   */
-  __setLogger(logger) {
-    this.logger = logger;
-    this.logger.debug(`Logger updated for exporter [name=${this.name}]`);
+  _seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClean(item, options, _seen, _depth + 1));
   }
-  /**
-   * Convert string log level to LogLevel enum
-   */
-  resolveLogLevel(logLevel) {
-    if (!logLevel) {
-      return LogLevel.INFO;
+  const cleaned = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (keysToStrip.has(key)) {
+      continue;
     }
-    if (typeof logLevel === "number") {
-      return logLevel;
+    try {
+      cleaned[key] = deepClean(val, options, _seen, _depth + 1);
+    } catch (error) {
+      cleaned[key] = `[${error instanceof Error ? error.message : String(error)}]`;
+    }
+  }
+  return cleaned;
+}
+var DefaultSpan = class extends BaseSpan {
+  id;
+  traceId;
+  constructor(options, observabilityInstance) {
+    super(options, observabilityInstance);
+    this.id = generateSpanId();
+    if (options.parent) {
+      this.traceId = options.parent.traceId;
+    } else if (options.traceId) {
+      if (isValidTraceId(options.traceId)) {
+        this.traceId = options.traceId;
+      } else {
+        console.error(
+          `[Mastra Tracing] Invalid traceId: must be 1-32 hexadecimal characters, got "${options.traceId}". Generating new trace ID.`
+        );
+        this.traceId = generateTraceId();
+      }
+    } else {
+      this.traceId = generateTraceId();
+    }
+    if (!options.parent && options.parentSpanId) {
+      if (isValidSpanId(options.parentSpanId)) {
+        this.parentSpanId = options.parentSpanId;
+      } else {
+        console.error(
+          `[Mastra Tracing] Invalid parentSpanId: must be 1-16 hexadecimal characters, got "${options.parentSpanId}". Ignoring parent span ID.`
+        );
+      }
     }
-    const logLevelMap = {
-      debug: LogLevel.DEBUG,
-      info: LogLevel.INFO,
-      warn: LogLevel.WARN,
-      error: LogLevel.ERROR
-    };
-    return logLevelMap[logLevel] ?? LogLevel.INFO;
-  }
-  /**
-   * Mark the exporter as disabled and log a message
-   *
-   * @param reason - Reason why the exporter is disabled
-   */
-  setDisabled(reason) {
-    this.isDisabled = true;
-    this.logger.warn(`${this.name} disabled: ${reason}`);
   }
-  /**
-   * Export a tracing event
-   *
-   * This method checks if the exporter is disabled before calling _exportEvent.
-   * Subclasses should implement _exportEvent instead of overriding this method.
-   */
-  async exportEvent(event) {
-    if (this.isDisabled) {
+  end(options) {
+    if (this.isEvent) {
       return;
     }
-    await this._exportEvent(event);
-  }
-  /**
-   * Shutdown the exporter and clean up resources
-   *
-   * Default implementation just logs. Override to add custom cleanup.
-   */
-  async shutdown() {
-    this.logger.info(`${this.name} shutdown complete`);
+    this.endTime = /* @__PURE__ */ new Date();
+    if (options?.output !== void 0) {
+      this.output = deepClean(options.output);
+    }
+    if (options?.attributes) {
+      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
+    }
+    if (options?.metadata) {
+      this.metadata = { ...this.metadata, ...deepClean(options.metadata) };
+    }
   }
-};
-var CloudExporter = class extends BaseExporter {
-  name = "mastra-cloud-ai-tracing-exporter";
-  config;
-  buffer;
-  flushTimer = null;
-  constructor(config = {}) {
-    super(config);
-    const accessToken = config.accessToken ?? process.env.MASTRA_CLOUD_ACCESS_TOKEN;
-    if (!accessToken) {
-      this.setDisabled(
-        "MASTRA_CLOUD_ACCESS_TOKEN environment variable not set. \u{1F680} Sign up for Mastra Cloud at https://cloud.mastra.ai to see your AI traces online and obtain your access token."
-      );
+  error(options) {
+    if (this.isEvent) {
+      return;
     }
-    const endpoint = config.endpoint ?? process.env.MASTRA_CLOUD_AI_TRACES_ENDPOINT ?? "https://api.mastra.ai/ai/spans/publish";
-    this.config = {
-      logger: this.logger,
-      logLevel: config.logLevel ?? LogLevel.INFO,
-      maxBatchSize: config.maxBatchSize ?? 1e3,
-      maxBatchWaitMs: config.maxBatchWaitMs ?? 5e3,
-      maxRetries: config.maxRetries ?? 3,
-      accessToken: accessToken || "",
-      endpoint
-    };
-    this.buffer = {
-      spans: [],
-      totalSize: 0
+    const { error, endSpan = true, attributes, metadata } = options;
+    this.errorInfo = error instanceof MastraError ? {
+      id: error.id,
+      details: error.details,
+      category: error.category,
+      domain: error.domain,
+      message: error.message
+    } : {
+      message: error.message
     };
+    if (attributes) {
+      this.attributes = { ...this.attributes, ...deepClean(attributes) };
+    }
+    if (metadata) {
+      this.metadata = { ...this.metadata, ...deepClean(metadata) };
+    }
+    if (endSpan) {
+      this.end();
+    } else {
+      this.update({});
+    }
   }
-  async _exportEvent(event) {
-    if (event.type !== AITracingEventType.SPAN_ENDED) {
+  update(options) {
+    if (this.isEvent) {
       return;
     }
-    this.addToBuffer(event);
-    if (this.shouldFlush()) {
-      this.flush().catch((error) => {
-        this.logger.error("Batch flush failed", {
-          error: error instanceof Error ? error.message : String(error)
-        });
-      });
-    } else if (this.buffer.totalSize === 1) {
-      this.scheduleFlush();
+    if (options.input !== void 0) {
+      this.input = deepClean(options.input);
     }
-  }
-  addToBuffer(event) {
-    if (this.buffer.totalSize === 0) {
-      this.buffer.firstEventTime = /* @__PURE__ */ new Date();
+    if (options.output !== void 0) {
+      this.output = deepClean(options.output);
     }
-    const spanRecord = this.formatSpan(event.exportedSpan);
-    this.buffer.spans.push(spanRecord);
-    this.buffer.totalSize++;
-  }
-  formatSpan(span) {
-    const spanRecord = {
-      traceId: span.traceId,
-      spanId: span.id,
-      parentSpanId: span.parentSpanId ?? null,
-      name: span.name,
-      spanType: span.type,
-      attributes: span.attributes ?? null,
-      metadata: span.metadata ?? null,
-      startedAt: span.startTime,
-      endedAt: span.endTime ?? null,
-      input: span.input ?? null,
-      output: span.output ?? null,
-      error: span.errorInfo,
-      isEvent: span.isEvent,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: null
-    };
-    return spanRecord;
-  }
-  shouldFlush() {
-    if (this.buffer.totalSize >= this.config.maxBatchSize) {
-      return true;
+    if (options.attributes) {
+      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
     }
-    if (this.buffer.firstEventTime && this.buffer.totalSize > 0) {
-      const elapsed = Date.now() - this.buffer.firstEventTime.getTime();
-      if (elapsed >= this.config.maxBatchWaitMs) {
-        return true;
-      }
+    if (options.metadata) {
+      this.metadata = { ...this.metadata, ...deepClean(options.metadata) };
     }
-    return false;
   }
-  scheduleFlush() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-    }
-    this.flushTimer = setTimeout(() => {
-      this.flush().catch((error) => {
-        const mastraError = new MastraError(
-          {
-            id: `CLOUD_AI_TRACING_FAILED_TO_SCHEDULE_FLUSH`,
-            domain: ErrorDomain.MASTRA_OBSERVABILITY,
-            category: ErrorCategory.USER
-          },
-          error
-        );
-        this.logger.trackException(mastraError);
-        this.logger.error("Scheduled flush failed", mastraError);
-      });
-    }, this.config.maxBatchWaitMs);
+  get isValid() {
+    return true;
   }
-  async flush() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    if (this.buffer.totalSize === 0) {
-      return;
+  async export() {
+    return JSON.stringify({
+      spanId: this.id,
+      traceId: this.traceId,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      attributes: this.attributes,
+      metadata: this.metadata
+    });
+  }
+};
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 8; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
     }
-    const startTime = Date.now();
-    const spansCopy = [...this.buffer.spans];
-    const flushReason = this.buffer.totalSize >= this.config.maxBatchSize ? "size" : "time";
-    this.resetBuffer();
-    try {
-      await this.batchUpload(spansCopy);
-      const elapsed = Date.now() - startTime;
-      this.logger.debug("Batch flushed successfully", {
-        batchSize: spansCopy.length,
-        flushReason,
-        durationMs: elapsed
-      });
-    } catch (error) {
-      const mastraError = new MastraError(
-        {
-          id: `CLOUD_AI_TRACING_FAILED_TO_BATCH_UPLOAD`,
-          domain: ErrorDomain.MASTRA_OBSERVABILITY,
-          category: ErrorCategory.USER,
-          details: {
-            droppedBatchSize: spansCopy.length
-          }
-        },
-        error
-      );
-      this.logger.trackException(mastraError);
-      this.logger.error("Batch upload failed after all retries, dropping batch", mastraError);
+  }
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
     }
   }
-  /**
-   * Uploads spans to cloud API using fetchWithRetry for all retry logic
-   */
-  async batchUpload(spans) {
-    const headers = {
-      Authorization: `Bearer ${this.config.accessToken}`,
-      "Content-Type": "application/json"
-    };
-    const options = {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ spans })
-    };
-    await fetchWithRetry(this.config.endpoint, options, this.config.maxRetries);
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function isValidTraceId(traceId) {
+  return /^[0-9a-f]{1,32}$/i.test(traceId);
+}
+function isValidSpanId(spanId) {
+  return /^[0-9a-f]{1,16}$/i.test(spanId);
+}
+
+// src/spans/no-op.ts
+var NoOpSpan = class extends BaseSpan {
+  id;
+  traceId;
+  constructor(options, observabilityInstance) {
+    super(options, observabilityInstance);
+    this.id = "no-op";
+    this.traceId = "no-op-trace";
+  }
+  end(_options) {
   }
-  resetBuffer() {
-    this.buffer.spans = [];
-    this.buffer.firstEventTime = void 0;
-    this.buffer.totalSize = 0;
+  error(_options) {
   }
-  async shutdown() {
-    if (this.isDisabled) {
-      return;
-    }
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    if (this.buffer.totalSize > 0) {
-      this.logger.info("Flushing remaining events on shutdown", {
-        remainingEvents: this.buffer.totalSize
-      });
-      try {
-        await this.flush();
-      } catch (error) {
-        const mastraError = new MastraError(
-          {
-            id: `CLOUD_AI_TRACING_FAILED_TO_FLUSH_REMAINING_EVENTS_DURING_SHUTDOWN`,
-            domain: ErrorDomain.MASTRA_OBSERVABILITY,
-            category: ErrorCategory.USER,
-            details: {
-              remainingEvents: this.buffer.totalSize
-            }
-          },
-          error
-        );
-        this.logger.trackException(mastraError);
-        this.logger.error("Failed to flush remaining events during shutdown", mastraError);
-      }
-    }
-    this.logger.info("CloudExporter shutdown complete");
+  update(_options) {
+  }
+  get isValid() {
+    return false;
   }
 };
-var ConsoleExporter = class extends BaseExporter {
-  name = "tracing-console-exporter";
-  constructor(config = {}) {
-    super(config);
+
+// src/instances/base.ts
+var BaseObservabilityInstance = class extends MastraBase {
+  config;
+  constructor(config) {
+    super({ component: RegisteredLogger.OBSERVABILITY, name: config.serviceName });
+    this.config = {
+      serviceName: config.serviceName,
+      name: config.name,
+      sampling: config.sampling ?? { type: "always" /* ALWAYS */ },
+      exporters: config.exporters ?? [],
+      spanOutputProcessors: config.spanOutputProcessors ?? [],
+      includeInternalSpans: config.includeInternalSpans ?? false,
+      requestContextKeys: config.requestContextKeys ?? []
+    };
   }
-  async _exportEvent(event) {
-    const span = event.exportedSpan;
-    const formatAttributes = (attributes) => {
-      try {
-        return JSON.stringify(attributes, null, 2);
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown formatting error";
-        return `[Unable to serialize attributes: ${errMsg}]`;
+  /**
+   * Override setLogger to add Observability specific initialization log
+   * and propagate logger to exporters
+   */
+  __setLogger(logger) {
+    super.__setLogger(logger);
+    this.exporters.forEach((exporter) => {
+      if (typeof exporter.__setLogger === "function") {
+        exporter.__setLogger(logger);
       }
-    };
-    const formatDuration = (startTime, endTime) => {
-      if (!endTime) return "N/A";
-      const duration = endTime.getTime() - startTime.getTime();
-      return `${duration}ms`;
-    };
-    switch (event.type) {
-      case AITracingEventType.SPAN_STARTED:
-        this.logger.info(`\u{1F680} SPAN_STARTED`);
-        this.logger.info(`   Type: ${span.type}`);
-        this.logger.info(`   Name: ${span.name}`);
-        this.logger.info(`   ID: ${span.id}`);
-        this.logger.info(`   Trace ID: ${span.traceId}`);
-        if (span.input !== void 0) {
-          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
-        }
-        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
-        this.logger.info("\u2500".repeat(80));
-        break;
-      case AITracingEventType.SPAN_ENDED:
-        const duration = formatDuration(span.startTime, span.endTime);
-        this.logger.info(`\u2705 SPAN_ENDED`);
-        this.logger.info(`   Type: ${span.type}`);
-        this.logger.info(`   Name: ${span.name}`);
-        this.logger.info(`   ID: ${span.id}`);
-        this.logger.info(`   Duration: ${duration}`);
-        this.logger.info(`   Trace ID: ${span.traceId}`);
-        if (span.input !== void 0) {
-          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
-        }
-        if (span.output !== void 0) {
-          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
-        }
-        if (span.errorInfo) {
-          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
-        }
-        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
-        this.logger.info("\u2500".repeat(80));
-        break;
-      case AITracingEventType.SPAN_UPDATED:
-        this.logger.info(`\u{1F4DD} SPAN_UPDATED`);
-        this.logger.info(`   Type: ${span.type}`);
-        this.logger.info(`   Name: ${span.name}`);
-        this.logger.info(`   ID: ${span.id}`);
-        this.logger.info(`   Trace ID: ${span.traceId}`);
-        if (span.input !== void 0) {
-          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
-        }
-        if (span.output !== void 0) {
-          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
-        }
-        if (span.errorInfo) {
-          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
-        }
-        this.logger.info(`   Updated Attributes: ${formatAttributes(span.attributes)}`);
-        this.logger.info("\u2500".repeat(80));
-        break;
-      default:
-        this.logger.warn(`Tracing event type not implemented: ${event.type}`);
-    }
+    });
+    this.logger.debug(
+      `[Observability] Initialized [service=${this.config.serviceName}] [instance=${this.config.name}] [sampling=${this.config.sampling.type}]`
+    );
   }
-  async shutdown() {
-    this.logger.info("ConsoleExporter shutdown");
+  // ============================================================================
+  // Protected getters for clean config access
+  // ============================================================================
+  get exporters() {
+    return this.config.exporters || [];
   }
-};
-function resolveStrategy(userConfig, storage, logger) {
-  if (userConfig.strategy && userConfig.strategy !== "auto") {
-    const hints = storage.aiTracingStrategy;
-    if (hints.supported.includes(userConfig.strategy)) {
-      return userConfig.strategy;
-    }
-    logger.warn("User-specified AI tracing strategy not supported by storage adapter, falling back to auto-selection", {
-      userStrategy: userConfig.strategy,
-      storageAdapter: storage.constructor.name,
-      supportedStrategies: hints.supported,
-      fallbackStrategy: hints.preferred
-    });
+  get spanOutputProcessors() {
+    return this.config.spanOutputProcessors || [];
   }
-  return storage.aiTracingStrategy.preferred;
-}
-var DefaultExporter = class {
-  name = "tracing-default-exporter";
-  logger;
-  storage;
-  config;
-  resolvedStrategy;
-  buffer;
-  flushTimer = null;
-  // Track all spans that have been created, persists across flushes
-  allCreatedSpans = /* @__PURE__ */ new Set();
-  constructor(config = {}, logger) {
-    if (logger) {
-      this.logger = logger;
+  // ============================================================================
+  // Public API - Single type-safe span creation method
+  // ============================================================================
+  /**
+   * Start a new span of a specific SpanType
+   */
+  startSpan(options) {
+    const { customSamplerOptions, requestContext, metadata, tracingOptions, ...rest } = options;
+    if (!this.shouldSample(customSamplerOptions)) {
+      return new NoOpSpan({ ...rest, metadata }, this);
+    }
+    let traceState;
+    if (options.parent) {
+      traceState = options.parent.traceState;
     } else {
-      this.logger = new ConsoleLogger({ level: LogLevel.INFO });
+      traceState = this.computeTraceState(tracingOptions);
     }
-    this.config = {
-      maxBatchSize: config.maxBatchSize ?? 1e3,
-      maxBufferSize: config.maxBufferSize ?? 1e4,
-      maxBatchWaitMs: config.maxBatchWaitMs ?? 5e3,
-      maxRetries: config.maxRetries ?? 4,
-      retryDelayMs: config.retryDelayMs ?? 500,
-      strategy: config.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";
+    const enrichedMetadata = this.extractMetadataFromRequestContext(requestContext, metadata, traceState);
+    const span = this.createSpan({
+      ...rest,
+      metadata: enrichedMetadata,
+      traceState
+    });
+    if (span.isEvent) {
+      this.emitSpanEnded(span);
+    } else {
+      this.wireSpanLifecycle(span);
+      this.emitSpanStarted(span);
+    }
+    return span;
   }
-  strategyInitialized = false;
+  // ============================================================================
+  // Configuration Management
+  // ============================================================================
   /**
-   * Initialize the exporter (called after all dependencies are ready)
+   * Get current configuration
    */
-  init(options) {
-    this.storage = options.mastra?.getStorage();
-    if (!this.storage) {
-      this.logger.warn("DefaultExporter disabled: Storage not available. Traces will not be persisted.");
-      return;
-    }
-    this.initializeStrategy(this.storage);
+  getConfig() {
+    return { ...this.config };
   }
+  // ============================================================================
+  // Plugin Access
+  // ============================================================================
   /**
-   * Initialize the resolved strategy once storage is available
+   * Get all exporters
    */
-  initializeStrategy(storage) {
-    if (this.strategyInitialized) return;
-    this.resolvedStrategy = resolveStrategy(this.config, storage, this.logger);
-    this.strategyInitialized = true;
-    this.logger.debug("AI tracing exporter initialized", {
-      strategy: this.resolvedStrategy,
-      source: this.config.strategy !== "auto" ? "user" : "auto",
-      storageAdapter: storage.constructor.name,
-      maxBatchSize: this.config.maxBatchSize,
-      maxBatchWaitMs: this.config.maxBatchWaitMs
-    });
+  getExporters() {
+    return [...this.exporters];
   }
   /**
-   * Builds a unique span key for tracking
+   * Get all span output processors
    */
-  buildSpanKey(traceId, spanId) {
-    return `${traceId}:${spanId}`;
+  getSpanOutputProcessors() {
+    return [...this.spanOutputProcessors];
   }
   /**
-   * Gets the next sequence number for a span
+   * Get the logger instance (for exporters and other components)
    */
-  getNextSequence(spanKey) {
-    const current = this.buffer.spanSequences.get(spanKey) || 0;
-    const next = current + 1;
-    this.buffer.spanSequences.set(spanKey, next);
-    return next;
+  getLogger() {
+    return this.logger;
   }
+  // ============================================================================
+  // Span Lifecycle Management
+  // ============================================================================
   /**
-   * Handles out-of-order span updates by logging and skipping
+   * Automatically wires up Observability lifecycle events for any span
+   * This ensures all spans emit events regardless of implementation
    */
-  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
-    });
+  wireSpanLifecycle(span) {
+    if (!this.config.includeInternalSpans && span.isInternal) {
+      return;
+    }
+    const originalEnd = span.end.bind(span);
+    const originalUpdate = span.update.bind(span);
+    span.end = (options) => {
+      if (span.isEvent) {
+        this.logger.warn(`End event is not available on event spans`);
+        return;
+      }
+      originalEnd(options);
+      this.emitSpanEnded(span);
+    };
+    span.update = (options) => {
+      if (span.isEvent) {
+        this.logger.warn(`Update() is not available on event spans`);
+        return;
+      }
+      originalUpdate(options);
+      this.emitSpanUpdated(span);
+    };
   }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
   /**
-   * Adds an event to the appropriate buffer based on strategy
+   * Check if an AI trace should be sampled
    */
-  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 AITracingEventType.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 AITracingEventType.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 AITracingEventType.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);
+  shouldSample(options) {
+    const { sampling } = this.config;
+    switch (sampling.type) {
+      case "always" /* ALWAYS */:
+        return true;
+      case "never" /* NEVER */:
+        return false;
+      case "ratio" /* RATIO */:
+        if (sampling.probability === void 0 || sampling.probability < 0 || sampling.probability > 1) {
+          this.logger.warn(
+            `Invalid sampling probability: ${sampling.probability}. Expected value between 0 and 1. Defaulting to no sampling.`
+          );
+          return false;
         }
-        break;
+        return Math.random() < sampling.probability;
+      case "custom" /* CUSTOM */:
+        return sampling.sampler(options);
+      default:
+        throw new Error(`Sampling strategy type not implemented: ${sampling.type}`);
     }
-    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
+   * Compute TraceState for a new trace based on configured and per-request keys
    */
-  shouldFlush() {
-    if (this.buffer.totalSize >= this.config.maxBufferSize) {
-      return true;
+  computeTraceState(tracingOptions) {
+    const configuredKeys = this.config.requestContextKeys ?? [];
+    const additionalKeys = tracingOptions?.requestContextKeys ?? [];
+    const allKeys = [...configuredKeys, ...additionalKeys];
+    if (allKeys.length === 0) {
+      return void 0;
     }
-    if (this.buffer.totalSize >= this.config.maxBatchSize) {
-      return true;
+    return {
+      requestContextKeys: allKeys
+    };
+  }
+  /**
+   * Extract metadata from RequestContext using TraceState
+   */
+  extractMetadataFromRequestContext(requestContext, explicitMetadata, traceState) {
+    if (!requestContext || !traceState || traceState.requestContextKeys.length === 0) {
+      return explicitMetadata;
     }
-    if (this.buffer.firstEventTime && this.buffer.totalSize > 0) {
-      const elapsed = Date.now() - this.buffer.firstEventTime.getTime();
-      if (elapsed >= this.config.maxBatchWaitMs) {
-        return true;
-      }
+    const extracted = this.extractKeys(requestContext, traceState.requestContextKeys);
+    if (Object.keys(extracted).length === 0 && !explicitMetadata) {
+      return void 0;
     }
-    return false;
+    return {
+      ...extracted,
+      ...explicitMetadata
+      // Explicit metadata always wins
+    };
   }
   /**
-   * Resets the buffer after successful flush
+   * Extract specific keys from RequestContext
    */
-  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);
+  extractKeys(requestContext, keys) {
+    const result = {};
+    for (const key of keys) {
+      const parts = key.split(".");
+      const rootKey = parts[0];
+      const value = requestContext.get(rootKey);
+      if (value !== void 0) {
+        if (parts.length > 1) {
+          const nestedPath = parts.slice(1).join(".");
+          const nestedValue = getNestedValue(value, nestedPath);
+          if (nestedValue !== void 0) {
+            setNestedValue(result, key, nestedValue);
+          }
+        } else {
+          setNestedValue(result, key, value);
+        }
+      }
     }
+    return result;
   }
   /**
-   * Schedules a flush using setTimeout
+   * Process a span through all output processors
    */
-  scheduleFlush() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
+  processSpan(span) {
+    for (const processor of this.spanOutputProcessors) {
+      if (!span) {
+        break;
+      }
+      try {
+        span = processor.process(span);
+      } catch (error) {
+        this.logger.error(`[Observability] Processor error [name=${processor.name}]`, error);
+      }
     }
-    this.flushTimer = setTimeout(() => {
-      this.flush().catch((error) => {
-        this.logger.error("Scheduled flush failed", {
-          error: error instanceof Error ? error.message : String(error)
-        });
-      });
-    }, this.config.maxBatchWaitMs);
+    return span;
+  }
+  // ============================================================================
+  // Event-driven Export Methods
+  // ============================================================================
+  getSpanForExport(span) {
+    if (!span.isValid) return void 0;
+    if (span.isInternal && !this.config.includeInternalSpans) return void 0;
+    const processedSpan = this.processSpan(span);
+    return processedSpan?.exportSpan(this.config.includeInternalSpans);
   }
   /**
-   * Serializes span attributes to storage record format
-   * Handles all AI span types and their specific attributes
+   * Emit a span started event
    */
-  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 (error) {
-      this.logger.warn("Failed to serialize span attributes, storing as null", {
-        spanId: span.id,
-        spanType: span.type,
-        error: error instanceof Error ? error.message : String(error)
+  emitSpanStarted(span) {
+    const exportedSpan = this.getSpanForExport(span);
+    if (exportedSpan) {
+      this.exportTracingEvent({ type: TracingEventType.SPAN_STARTED, exportedSpan }).catch((error) => {
+        this.logger.error("[Observability] Failed to export span_started event", error);
       });
-      return null;
     }
   }
-  buildCreateRecord(span) {
-    return {
-      traceId: span.traceId,
-      spanId: span.id,
-      parentSpanId: span.parentSpanId ?? null,
-      name: span.name,
-      scope: null,
-      spanType: span.type,
-      attributes: this.serializeAttributes(span),
-      metadata: span.metadata ?? null,
-      links: null,
-      startedAt: span.startTime,
-      endedAt: span.endTime ?? null,
-      input: span.input,
-      output: span.output,
-      error: span.errorInfo,
-      isEvent: span.isEvent
-    };
-  }
-  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
-    };
-  }
   /**
-   * Handles realtime strategy - processes each event immediately
+   * Emit a span ended event (called automatically when spans end)
    */
-  async handleRealtimeEvent(event, storage) {
-    const span = event.exportedSpan;
-    const spanKey = this.buildSpanKey(span.traceId, span.id);
-    if (span.isEvent) {
-      if (event.type === AITracingEventType.SPAN_ENDED) {
-        await storage.createAISpan(this.buildCreateRecord(event.exportedSpan));
-      } else {
-        this.logger.warn(`Tracing event type not implemented for event spans: ${event.type}`);
-      }
-    } else {
-      switch (event.type) {
-        case AITracingEventType.SPAN_STARTED:
-          await storage.createAISpan(this.buildCreateRecord(event.exportedSpan));
-          this.allCreatedSpans.add(spanKey);
-          break;
-        case AITracingEventType.SPAN_UPDATED:
-          await storage.updateAISpan({
-            traceId: span.traceId,
-            spanId: span.id,
-            updates: this.buildUpdateRecord(span)
-          });
-          break;
-        case AITracingEventType.SPAN_ENDED:
-          await storage.updateAISpan({
-            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}`);
-      }
+  emitSpanEnded(span) {
+    const exportedSpan = this.getSpanForExport(span);
+    if (exportedSpan) {
+      this.exportTracingEvent({ type: TracingEventType.SPAN_ENDED, exportedSpan }).catch((error) => {
+        this.logger.error("[Observability] Failed to export span_ended event", error);
+      });
     }
   }
   /**
-   * Handles batch-with-updates strategy - buffers events and processes in batches
+   * Emit a span updated event
    */
-  handleBatchWithUpdatesEvent(event) {
-    this.addToBuffer(event);
-    if (this.shouldFlush()) {
-      this.flush().catch((error) => {
-        this.logger.error("Batch flush failed", {
-          error: error instanceof Error ? error.message : String(error)
-        });
+  emitSpanUpdated(span) {
+    const exportedSpan = this.getSpanForExport(span);
+    if (exportedSpan) {
+      this.exportTracingEvent({ type: TracingEventType.SPAN_UPDATED, exportedSpan }).catch((error) => {
+        this.logger.error("[Observability] Failed to export span_updated event", error);
       });
-    } else if (this.buffer.totalSize === 1) {
-      this.scheduleFlush();
     }
   }
   /**
-   * Handles insert-only strategy - only processes SPAN_ENDED events in batches
+   * Export tracing event through all exporters (realtime mode)
    */
-  handleInsertOnlyEvent(event) {
-    if (event.type === AITracingEventType.SPAN_ENDED) {
-      this.addToBuffer(event);
-      if (this.shouldFlush()) {
-        this.flush().catch((error) => {
-          this.logger.error("Batch flush failed", {
-            error: error instanceof Error ? error.message : String(error)
-          });
-        });
-      } else if (this.buffer.totalSize === 1) {
-        this.scheduleFlush();
+  async exportTracingEvent(event) {
+    const exportPromises = this.exporters.map(async (exporter) => {
+      try {
+        if (exporter.exportTracingEvent) {
+          await exporter.exportTracingEvent(event);
+          this.logger.debug(`[Observability] Event exported [exporter=${exporter.name}] [type=${event.type}]`);
+        }
+      } catch (error) {
+        this.logger.error(`[Observability] Export error [exporter=${exporter.name}]`, error);
       }
-    }
+    });
+    await Promise.allSettled(exportPromises);
   }
+  // ============================================================================
+  // Lifecycle Management
+  // ============================================================================
   /**
-   * Calculates retry delay using exponential backoff
+   * Initialize Observability (called by Mastra during component registration)
    */
-  calculateRetryDelay(attempt) {
-    return this.config.retryDelayMs * Math.pow(2, attempt);
+  init() {
+    this.logger.debug(`[Observability] Initialization started [name=${this.name}]`);
+    this.logger.info(`[Observability] Initialized successfully [name=${this.name}]`);
   }
   /**
-   * Flushes the current buffer to storage with retry logic
+   * Shutdown Observability and clean up resources
    */
-  async flush() {
-    if (!this.storage) {
-      this.logger.debug("Cannot flush traces. Mastra storage is not initialized");
-      return;
-    }
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
+  async shutdown() {
+    this.logger.debug(`[Observability] Shutdown started [name=${this.name}]`);
+    const shutdownPromises = [
+      ...this.exporters.map((e) => e.shutdown()),
+      ...this.spanOutputProcessors.map((p) => p.shutdown())
+    ];
+    await Promise.allSettled(shutdownPromises);
+    this.logger.info(`[Observability] Shutdown completed [name=${this.name}]`);
+  }
+};
+
+// src/instances/default.ts
+var DefaultObservabilityInstance = class extends BaseObservabilityInstance {
+  constructor(config) {
+    super(config);
+  }
+  createSpan(options) {
+    return new DefaultSpan(options, this);
+  }
+};
+
+// src/registry.ts
+var ObservabilityRegistry = class {
+  #instances = /* @__PURE__ */ new Map();
+  #defaultInstance;
+  #configSelector;
+  /**
+   * Register a tracing instance
+   */
+  register(name, instance, isDefault = false) {
+    if (this.#instances.has(name)) {
+      throw new Error(`Tracing instance '${name}' already registered`);
     }
-    if (this.buffer.totalSize === 0) {
-      return;
+    this.#instances.set(name, instance);
+    if (isDefault || !this.#defaultInstance) {
+      this.#defaultInstance = instance;
     }
-    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.storage, bufferCopy, 0);
-    const elapsed = Date.now() - startTime;
-    this.logger.debug("Batch flushed", {
-      strategy: this.resolvedStrategy,
-      batchSize: bufferCopy.totalSize,
-      flushReason,
-      durationMs: elapsed,
-      outOfOrderCount: bufferCopy.outOfOrderCount > 0 ? bufferCopy.outOfOrderCount : void 0
-    });
   }
   /**
-   * Attempts to flush with exponential backoff retry logic
+   * Get a tracing instance by name
    */
-  async flushWithRetries(storage, buffer, attempt) {
-    try {
-      if (this.resolvedStrategy === "batch-with-updates") {
-        if (buffer.creates.length > 0) {
-          await storage.batchCreateAISpans({ 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 storage.batchUpdateAISpans({ records: sortedUpdates });
-        }
-      } else if (this.resolvedStrategy === "insert-only") {
-        if (buffer.insertOnly.length > 0) {
-          await storage.batchCreateAISpans({ records: buffer.insertOnly });
-        }
-      }
-      for (const spanKey of buffer.completedSpans) {
-        this.allCreatedSpans.delete(spanKey);
-      }
-    } catch (error) {
-      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: error instanceof Error ? error.message : String(error)
-        });
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        return this.flushWithRetries(storage, 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: error instanceof Error ? error.message : String(error)
-        });
-        for (const spanKey of buffer.completedSpans) {
-          this.allCreatedSpans.delete(spanKey);
-        }
+  get(name) {
+    return this.#instances.get(name);
+  }
+  /**
+   * Get the default tracing instance
+   */
+  getDefault() {
+    return this.#defaultInstance;
+  }
+  /**
+   * Set the tracing selector function
+   */
+  setSelector(selector) {
+    this.#configSelector = selector;
+  }
+  /**
+   * Get the selected tracing instance based on context
+   */
+  getSelected(options) {
+    if (this.#configSelector) {
+      const selected = this.#configSelector(options, this.#instances);
+      if (selected && this.#instances.has(selected)) {
+        return this.#instances.get(selected);
       }
     }
+    return this.#defaultInstance;
   }
-  async exportEvent(event) {
-    if (!this.storage) {
-      this.logger.debug("Cannot store traces. Mastra storage is not initialized");
-      return;
-    }
-    if (!this.strategyInitialized) {
-      this.initializeStrategy(this.storage);
-    }
-    switch (this.resolvedStrategy) {
-      case "realtime":
-        await this.handleRealtimeEvent(event, this.storage);
-        break;
-      case "batch-with-updates":
-        this.handleBatchWithUpdatesEvent(event);
-        break;
-      case "insert-only":
-        this.handleInsertOnlyEvent(event);
-        break;
+  /**
+   * Unregister a tracing instance
+   */
+  unregister(name) {
+    const instance = this.#instances.get(name);
+    const deleted = this.#instances.delete(name);
+    if (deleted && instance === this.#defaultInstance) {
+      const next = this.#instances.values().next();
+      this.#defaultInstance = next.done ? void 0 : next.value;
     }
+    return deleted;
   }
+  /**
+   * Shutdown all instances and clear the registry
+   */
   async shutdown() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    if (this.buffer.totalSize > 0) {
-      this.logger.info("Flushing remaining events on shutdown", {
-        remainingEvents: this.buffer.totalSize
-      });
-      try {
-        await this.flush();
-      } catch (error) {
-        this.logger.error("Failed to flush remaining events during shutdown", {
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    this.logger.info("DefaultExporter shutdown complete");
+    const shutdownPromises = Array.from(this.#instances.values()).map((instance) => instance.shutdown());
+    await Promise.allSettled(shutdownPromises);
+    this.#instances.clear();
+    this.#instances.clear();
+    this.#defaultInstance = void 0;
+    this.#configSelector = void 0;
+  }
+  /**
+   * Clear all instances without shutdown
+   */
+  clear() {
+    this.#instances.clear();
+    this.#defaultInstance = void 0;
+    this.#configSelector = void 0;
+  }
+  /**
+   * list all registered instances
+   */
+  list() {
+    return new Map(this.#instances);
   }
 };
 
@@ -1882,151 +1979,109 @@ var SensitiveDataFilter = class {
   async shutdown() {
   }
 };
-var AITracingRegistry = class {
-  instances = /* @__PURE__ */ new Map();
-  defaultInstance;
-  configSelector;
-  /**
-   * Register a tracing instance
-   */
-  register(name, instance, isDefault = false) {
-    if (this.instances.has(name)) {
-      throw new Error(`AI Tracing instance '${name}' already registered`);
+
+// src/default.ts
+function isInstance(obj) {
+  return obj instanceof BaseObservabilityInstance;
+}
+var Observability = class extends MastraBase {
+  #registry = new ObservabilityRegistry();
+  constructor(config) {
+    super({
+      component: RegisteredLogger.OBSERVABILITY,
+      name: "Observability"
+    });
+    if (config === void 0) {
+      config = {};
     }
-    this.instances.set(name, instance);
-    if (isDefault || !this.defaultInstance) {
-      this.defaultInstance = instance;
+    if (config.default?.enabled && config.configs?.["default"]) {
+      throw new Error(
+        "Cannot use 'default' as a custom config name when default tracing is enabled. Please rename your custom config to avoid conflicts."
+      );
     }
+    if (config.default?.enabled) {
+      const defaultInstance = new DefaultObservabilityInstance({
+        serviceName: "mastra",
+        name: "default",
+        sampling: { type: "always" /* ALWAYS */ },
+        exporters: [new DefaultExporter(), new CloudExporter()],
+        spanOutputProcessors: [new SensitiveDataFilter()]
+      });
+      this.#registry.register("default", defaultInstance, true);
+    }
+    if (config.configs) {
+      const instances = Object.entries(config.configs);
+      instances.forEach(([name, tracingDef], index) => {
+        const instance = isInstance(tracingDef) ? tracingDef : new DefaultObservabilityInstance({ ...tracingDef, name });
+        const isDefault = !config.default?.enabled && index === 0;
+        this.#registry.register(name, instance, isDefault);
+      });
+    }
+    if (config.configSelector) {
+      this.#registry.setSelector(config.configSelector);
+    }
+  }
+  setMastraContext(options) {
+    const instances = this.listInstances();
+    const { mastra } = options;
+    instances.forEach((instance) => {
+      const config = instance.getConfig();
+      const exporters = instance.getExporters();
+      exporters.forEach((exporter) => {
+        if ("init" in exporter && typeof exporter.init === "function") {
+          try {
+            exporter.init({ mastra, config });
+          } catch (error) {
+            this.logger?.warn("Failed to initialize observability exporter", {
+              exporterName: exporter.name,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        }
+      });
+    });
   }
-  /**
-   * Get a tracing instance by name
-   */
-  get(name) {
-    return this.instances.get(name);
-  }
-  /**
-   * Get the default tracing instance
-   */
-  getDefault() {
-    return this.defaultInstance;
+  setLogger(options) {
+    super.__setLogger(options.logger);
+    this.listInstances().forEach((instance) => {
+      instance.__setLogger(options.logger);
+    });
   }
-  /**
-   * Set the tracing selector function
-   */
-  setSelector(selector) {
-    this.configSelector = selector;
+  getSelectedInstance(options) {
+    return this.#registry.getSelected(options);
   }
   /**
-   * Get the selected tracing instance based on context
+   * Registry management methods
    */
-  getSelected(options) {
-    if (this.configSelector) {
-      const selected = this.configSelector(options, this.instances);
-      if (selected && this.instances.has(selected)) {
-        return this.instances.get(selected);
-      }
-    }
-    return this.defaultInstance;
+  registerInstance(name, instance, isDefault = false) {
+    this.#registry.register(name, instance, isDefault);
   }
-  /**
-   * Unregister a tracing instance
-   */
-  unregister(name) {
-    return this.instances.delete(name);
+  getInstance(name) {
+    return this.#registry.get(name);
   }
-  /**
-   * Shutdown all instances and clear the registry
-   */
-  async shutdown() {
-    const shutdownPromises = Array.from(this.instances.values()).map((instance) => instance.shutdown());
-    await Promise.allSettled(shutdownPromises);
-    this.instances.clear();
+  getDefaultInstance() {
+    return this.#registry.getDefault();
   }
-  /**
-   * Clear all instances without shutdown
-   */
-  clear() {
-    this.instances.clear();
-    this.defaultInstance = void 0;
-    this.configSelector = void 0;
+  listInstances() {
+    return this.#registry.list();
   }
-  /**
-   * Get all registered instances
-   */
-  getAll() {
-    return new Map(this.instances);
+  unregisterInstance(name) {
+    return this.#registry.unregister(name);
   }
-};
-var aiTracingRegistry = new AITracingRegistry();
-function registerAITracing(name, instance, isDefault = false) {
-  aiTracingRegistry.register(name, instance, isDefault);
-}
-function getAITracing(name) {
-  return aiTracingRegistry.get(name);
-}
-function getDefaultAITracing() {
-  return aiTracingRegistry.getDefault();
-}
-function setSelector(selector) {
-  aiTracingRegistry.setSelector(selector);
-}
-function getSelectedAITracing(options) {
-  return aiTracingRegistry.getSelected(options);
-}
-function unregisterAITracing(name) {
-  return aiTracingRegistry.unregister(name);
-}
-async function shutdownAITracingRegistry() {
-  await aiTracingRegistry.shutdown();
-}
-function clearAITracingRegistry() {
-  aiTracingRegistry.clear();
-}
-function getAllAITracing() {
-  return aiTracingRegistry.getAll();
-}
-function hasAITracing(name) {
-  const tracing = getAITracing(name);
-  if (!tracing) return false;
-  const config = tracing.getConfig();
-  const sampling = config.sampling;
-  return sampling.type !== SamplingStrategyType.NEVER;
-}
-function isAITracingInstance(obj) {
-  return obj instanceof BaseAITracing;
-}
-function setupAITracingRegistry(config) {
-  if (!config) {
-    return;
+  hasInstance(name) {
+    return !!this.#registry.get(name);
   }
-  if (config.default?.enabled && config.configs?.["default"]) {
-    throw new Error(
-      "Cannot use 'default' as a custom config name when default tracing is enabled. Please rename your custom config to avoid conflicts."
-    );
+  setConfigSelector(selector) {
+    this.#registry.setSelector(selector);
   }
-  if (config.default?.enabled) {
-    const defaultInstance = new DefaultAITracing({
-      serviceName: "mastra",
-      name: "default",
-      sampling: { type: SamplingStrategyType.ALWAYS },
-      exporters: [new DefaultExporter(), new CloudExporter()],
-      processors: [new SensitiveDataFilter()]
-    });
-    registerAITracing("default", defaultInstance, true);
-  }
-  if (config.configs) {
-    const instances = Object.entries(config.configs);
-    instances.forEach(([name, tracingDef], index) => {
-      const instance = isAITracingInstance(tracingDef) ? tracingDef : new DefaultAITracing({ ...tracingDef, name });
-      const isDefault = !config.default?.enabled && index === 0;
-      registerAITracing(name, instance, isDefault);
-    });
+  clear() {
+    this.#registry.clear();
   }
-  if (config.configSelector) {
-    setSelector(config.configSelector);
+  async shutdown() {
+    await this.#registry.shutdown();
   }
-}
+};
 
-export { BaseAISpan, BaseAITracing, BaseExporter, CloudExporter, ConsoleExporter, DefaultAISpan, DefaultAITracing, DefaultExporter, ModelSpanTracker, NoOpAISpan, SensitiveDataFilter, clearAITracingRegistry, deepClean, getAITracing, getAllAITracing, getDefaultAITracing, getSelectedAITracing, hasAITracing, registerAITracing, setSelector, setupAITracingRegistry, shutdownAITracingRegistry, unregisterAITracing };
+export { BaseExporter, BaseObservabilityInstance, BaseSpan, CloudExporter, ConsoleExporter, DefaultExporter, DefaultObservabilityInstance, DefaultSpan, ModelSpanTracker, NoOpSpan, Observability, SamplingStrategyType, SensitiveDataFilter, deepClean };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map