@mastra/observability 1.0.0-beta.6 → 1.0.0-beta.8

package/dist/index.js

@@ -4487,24 +4487,31 @@ var ConsoleExporter = class extends BaseExporter {
     this.logger.info("ConsoleExporter shutdown");
   }
 };
-function resolveTracingStorageStrategy(config, storage, logger) {
+function resolveTracingStorageStrategy(config, observability, storageName, logger) {
   if (config.strategy && config.strategy !== "auto") {
-    const hints = storage.tracingStrategy;
+    const hints = observability.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,
+      storageAdapter: storageName,
       supportedStrategies: hints.supported,
       fallbackStrategy: hints.preferred
     });
   }
-  return storage.tracingStrategy.preferred;
+  return observability.tracingStrategy.preferred;
+}
+function getStringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function getObjectOrNull(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 var DefaultExporter = class extends BaseExporter {
   name = "mastra-default-observability-exporter";
   #storage;
+  #observability;
   #config;
   #resolvedStrategy;
   buffer;
@@ -4541,25 +4548,30 @@ var DefaultExporter = class extends BaseExporter {
   /**
    * Initialize the exporter (called after all dependencies are ready)
    */
-  init(options) {
+  async 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);
+    this.#observability = await this.#storage.getStore("observability");
+    if (!this.#observability) {
+      this.logger.warn("DefaultExporter disabled: Observability storage not available. Traces will not be persisted.");
+      return;
+    }
+    this.initializeStrategy(this.#observability, this.#storage.constructor.name);
   }
   /**
-   * Initialize the resolved strategy once storage is available
+   * Initialize the resolved strategy once observability store is available
    */
-  initializeStrategy(storage) {
+  initializeStrategy(observability, storageName) {
     if (this.#strategyInitialized) return;
-    this.#resolvedStrategy = resolveTracingStorageStrategy(this.#config, storage, this.logger);
+    this.#resolvedStrategy = resolveTracingStorageStrategy(this.#config, observability, storageName, this.logger);
     this.#strategyInitialized = true;
     this.logger.debug("tracing storage exporter initialized", {
       strategy: this.#resolvedStrategy,
       source: this.#config.strategy !== "auto" ? "user" : "auto",
-      storageAdapter: storage.constructor.name,
+      storageAdapter: storageName,
       maxBatchSize: this.#config.maxBatchSize,
       maxBatchWaitMs: this.#config.maxBatchWaitMs
     });
@@ -4732,22 +4744,44 @@ var DefaultExporter = class extends BaseExporter {
     }
   }
   buildCreateRecord(span) {
+    const metadata = span.metadata ?? {};
     return {
       traceId: span.traceId,
       spanId: span.id,
       parentSpanId: span.parentSpanId ?? null,
       name: span.name,
-      scope: null,
+      // Entity identification - from span
+      entityType: span.entityType ?? null,
+      entityId: span.entityId ?? null,
+      entityName: span.entityName ?? null,
+      // Identity & Tenancy - extracted from metadata if present
+      userId: getStringOrNull(metadata.userId),
+      organizationId: getStringOrNull(metadata.organizationId),
+      resourceId: getStringOrNull(metadata.resourceId),
+      // Correlation IDs - extracted from metadata if present
+      runId: getStringOrNull(metadata.runId),
+      sessionId: getStringOrNull(metadata.sessionId),
+      threadId: getStringOrNull(metadata.threadId),
+      requestId: getStringOrNull(metadata.requestId),
+      // Deployment context - extracted from metadata if present
+      environment: getStringOrNull(metadata.environment),
+      source: getStringOrNull(metadata.source),
+      serviceName: getStringOrNull(metadata.serviceName),
+      scope: getObjectOrNull(metadata.scope),
+      // Span data
       spanType: span.type,
       attributes: this.serializeAttributes(span),
       metadata: span.metadata ?? null,
+      // Keep all metadata including extracted fields
+      tags: span.tags ?? null,
       links: null,
+      input: span.input ?? null,
+      output: span.output ?? null,
+      error: span.errorInfo ?? null,
+      isEvent: span.isEvent,
+      // Timestamps
       startedAt: span.startTime,
-      endedAt: span.endTime ?? null,
-      input: span.input,
-      output: span.output,
-      error: span.errorInfo,
-      isEvent: span.isEvent
+      endedAt: span.endTime ?? null
     };
   }
   buildUpdateRecord(span) {
@@ -4760,36 +4794,36 @@ var DefaultExporter = class extends BaseExporter {
       endedAt: span.endTime ?? null,
       input: span.input,
       output: span.output,
-      error: span.errorInfo
+      error: span.errorInfo ?? null
     };
   }
   /**
    * Handles realtime strategy - processes each event immediately
    */
-  async handleRealtimeEvent(event, storage) {
+  async handleRealtimeEvent(event, observability) {
     const span = event.exportedSpan;
     const spanKey = this.buildSpanKey(span.traceId, span.id);
     if (span.isEvent) {
       if (event.type === TracingEventType.SPAN_ENDED) {
-        await storage.createSpan(this.buildCreateRecord(event.exportedSpan));
+        await observability.createSpan({ span: 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));
+          await observability.createSpan({ span: this.buildCreateRecord(event.exportedSpan) });
           this.allCreatedSpans.add(spanKey);
           break;
         case TracingEventType.SPAN_UPDATED:
-          await storage.updateSpan({
+          await observability.updateSpan({
             traceId: span.traceId,
             spanId: span.id,
             updates: this.buildUpdateRecord(span)
           });
           break;
         case TracingEventType.SPAN_ENDED:
-          await storage.updateSpan({
+          await observability.updateSpan({
             traceId: span.traceId,
             spanId: span.id,
             updates: this.buildUpdateRecord(span)
@@ -4843,8 +4877,8 @@ var DefaultExporter = class extends BaseExporter {
    * 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");
+    if (!this.#observability) {
+      this.logger.debug("Cannot flush traces. Observability storage is not initialized");
       return;
     }
     if (this.#flushTimer) {
@@ -4868,7 +4902,7 @@ var DefaultExporter = class extends BaseExporter {
       totalSize: this.buffer.totalSize
     };
     this.resetBuffer();
-    await this.flushWithRetries(this.#storage, bufferCopy, 0);
+    await this.flushWithRetries(this.#observability, bufferCopy, 0);
     const elapsed = Date.now() - startTime;
     this.logger.debug("Batch flushed", {
       strategy: this.#resolvedStrategy,
@@ -4881,11 +4915,11 @@ var DefaultExporter = class extends BaseExporter {
   /**
    * Attempts to flush with exponential backoff retry logic
    */
-  async flushWithRetries(storage, buffer, attempt) {
+  async flushWithRetries(observability, buffer, attempt) {
     try {
       if (this.#resolvedStrategy === "batch-with-updates") {
         if (buffer.creates.length > 0) {
-          await storage.batchCreateSpans({ records: buffer.creates });
+          await observability.batchCreateSpans({ records: buffer.creates });
         }
         if (buffer.updates.length > 0) {
           const sortedUpdates = buffer.updates.sort((a, b) => {
@@ -4895,11 +4929,11 @@ var DefaultExporter = class extends BaseExporter {
             if (spanCompare !== 0) return spanCompare;
             return a.sequenceNumber - b.sequenceNumber;
           });
-          await storage.batchUpdateSpans({ records: sortedUpdates });
+          await observability.batchUpdateSpans({ records: sortedUpdates });
         }
       } else if (this.#resolvedStrategy === "insert-only") {
         if (buffer.insertOnly.length > 0) {
-          await storage.batchCreateSpans({ records: buffer.insertOnly });
+          await observability.batchCreateSpans({ records: buffer.insertOnly });
         }
       }
       for (const spanKey of buffer.completedSpans) {
@@ -4915,7 +4949,7 @@ var DefaultExporter = class extends BaseExporter {
           error: error instanceof Error ? error.message : String(error)
         });
         await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        return this.flushWithRetries(storage, buffer, attempt + 1);
+        return this.flushWithRetries(observability, buffer, attempt + 1);
       } else {
         this.logger.error("Batch flush failed after all retries, dropping batch", {
           finalAttempt: attempt + 1,
@@ -4930,16 +4964,16 @@ var DefaultExporter = class extends BaseExporter {
     }
   }
   async _exportTracingEvent(event) {
-    if (!this.#storage) {
-      this.logger.debug("Cannot store traces. Mastra storage is not initialized");
+    if (!this.#observability) {
+      this.logger.debug("Cannot store traces. Observability storage is not initialized");
       return;
     }
     if (!this.#strategyInitialized) {
-      this.initializeStrategy(this.#storage);
+      this.initializeStrategy(this.#observability, this.#storage?.constructor.name ?? "Unknown");
     }
     switch (this.#resolvedStrategy) {
       case "realtime":
-        await this.handleRealtimeEvent(event, this.#storage);
+        await this.handleRealtimeEvent(event, this.#observability);
         break;
       case "batch-with-updates":
         this.handleBatchWithUpdatesEvent(event);
@@ -5100,9 +5134,14 @@ var ModelSpanTracker = class {
     this.#modelSpan?.update(options);
   }
   /**
-   * Start a new Model execution step
+   * Start a new Model execution step.
+   * This should be called at the beginning of LLM execution to capture accurate startTime.
+   * The step-start chunk payload can be passed later via updateStep() if needed.
    */
-  #startStepSpan(payload) {
+  startStep(payload) {
+    if (this.#currentStepSpan) {
+      return;
+    }
     this.#currentStepSpan = this.#modelSpan?.createChildSpan({
       name: `step: ${this.#stepIndex}`,
       type: SpanType.MODEL_STEP,
@@ -5115,6 +5154,22 @@ var ModelSpanTracker = class {
     });
     this.#chunkSequence = 0;
   }
+  /**
+   * Update the current step span with additional payload data.
+   * Called when step-start chunk arrives with request/warnings info.
+   */
+  updateStep(payload) {
+    if (!this.#currentStepSpan || !payload) {
+      return;
+    }
+    this.#currentStepSpan.update({
+      input: payload.request,
+      attributes: {
+        ...payload.messageId ? { messageId: payload.messageId } : {},
+        ...payload.warnings?.length ? { warnings: payload.warnings } : {}
+      }
+    });
+  }
   /**
    * End the current Model execution step with token usage, finish reason, output, and metadata
    */
@@ -5149,7 +5204,7 @@ var ModelSpanTracker = class {
    */
   #startChunkSpan(chunkType, initialData) {
     if (!this.#currentStepSpan) {
-      this.#startStepSpan();
+      this.startStep();
     }
     this.#currentChunkSpan = this.#currentStepSpan?.createChildSpan({
       name: `chunk: '${chunkType}'`,
@@ -5189,7 +5244,7 @@ var ModelSpanTracker = class {
    */
   #createEventSpan(chunkType, output) {
     if (!this.#currentStepSpan) {
-      this.#startStepSpan();
+      this.startStep();
     }
     const span = this.#currentStepSpan?.createEventSpan({
       name: `chunk: '${chunkType}'`,
@@ -5308,7 +5363,7 @@ var ModelSpanTracker = class {
     let acc = this.#toolOutputAccumulators.get(toolCallId);
     if (!acc) {
       if (!this.#currentStepSpan) {
-        this.#startStepSpan();
+        this.startStep();
       }
       acc = {
         toolName: toolName || "unknown",
@@ -5408,7 +5463,11 @@ var ModelSpanTracker = class {
               this.#handleObjectChunk(chunk);
               break;
             case "step-start":
-              this.#startStepSpan(chunk.payload);
+              if (this.#currentStepSpan) {
+                this.updateStep(chunk.payload);
+              } else {
+                this.startStep(chunk.payload);
+              }
               break;
             case "step-finish":
               this.#endStepSpan(chunk.payload);
@@ -5615,6 +5674,12 @@ var BaseSpan = class {
   metadata;
   tags;
   traceState;
+  /** Entity type that created the span (e.g., agent, workflow) */
+  entityType;
+  /** Entity ID that created the span */
+  entityId;
+  /** Entity name that created the span */
+  entityName;
   /** Parent span ID (for root spans that are children of external spans) */
   parentSpanId;
   constructor(options, observabilityInstance) {
@@ -5629,6 +5694,9 @@ var BaseSpan = class {
     this.isInternal = isSpanInternal(this.type, options.tracingPolicy?.internal);
     this.traceState = options.traceState;
     this.tags = !options.parent && options.tags?.length ? options.tags : void 0;
+    this.entityType = options.entityType;
+    this.entityId = options.entityId;
+    this.entityName = options.entityName;
     if (this.isEvent) {
       this.output = deepClean(options.output);
     } else {
@@ -5682,6 +5750,9 @@ var BaseSpan = class {
       traceId: this.traceId,
       name: this.name,
       type: this.type,
+      entityType: this.entityType,
+      entityId: this.entityId,
+      entityName: this.entityName,
       attributes: this.attributes,
       metadata: this.metadata,
       startTime: this.startTime,