@mastra/observability 1.0.0-beta.5 → 1.0.0-beta.7

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);
@@ -5452,6 +5486,110 @@ var ModelSpanTracker = class {
   }
 };
 
+// src/spans/serialization.ts
+var DEFAULT_KEYS_TO_STRIP = /* @__PURE__ */ new Set([
+  "logger",
+  "experimental_providerMetadata",
+  "providerMetadata",
+  "steps",
+  "tracingContext"
+]);
+var DEFAULT_DEEP_CLEAN_OPTIONS = Object.freeze({
+  keysToStrip: DEFAULT_KEYS_TO_STRIP,
+  maxDepth: 6,
+  maxStringLength: 1024,
+  maxArrayLength: 50,
+  maxObjectKeys: 50
+});
+function truncateString(s, maxChars) {
+  if (s.length <= maxChars) {
+    return s;
+  }
+  return s.slice(0, maxChars) + "\u2026[truncated]";
+}
+function deepClean(value, options = DEFAULT_DEEP_CLEAN_OPTIONS) {
+  const { keysToStrip, maxDepth, maxStringLength, maxArrayLength, maxObjectKeys } = options;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function helper(val, depth) {
+    if (depth > maxDepth) {
+      return "[MaxDepth]";
+    }
+    if (val === null || val === void 0) {
+      return val;
+    }
+    if (typeof val === "string") {
+      return truncateString(val, maxStringLength);
+    }
+    if (typeof val === "number" || typeof val === "boolean") {
+      return val;
+    }
+    if (typeof val === "bigint") {
+      return `${val}n`;
+    }
+    if (typeof val === "function") {
+      return "[Function]";
+    }
+    if (typeof val === "symbol") {
+      return val.description ? `[Symbol(${val.description})]` : "[Symbol]";
+    }
+    if (val instanceof Date) {
+      return val;
+    }
+    if (val instanceof Error) {
+      return {
+        name: val.name,
+        message: val.message ? truncateString(val.message, maxStringLength) : void 0
+      };
+    }
+    if (typeof val === "object") {
+      if (seen.has(val)) {
+        return "[Circular]";
+      }
+      seen.add(val);
+    }
+    if (Array.isArray(val)) {
+      const limitedArray = val.slice(0, maxArrayLength);
+      const cleaned2 = limitedArray.map((item) => helper(item, depth + 1));
+      if (val.length > maxArrayLength) {
+        cleaned2.push(`[\u2026${val.length - maxArrayLength} more items]`);
+      }
+      return cleaned2;
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(val)) {
+      return `[Buffer length=${val.length}]`;
+    }
+    if (ArrayBuffer.isView(val)) {
+      const ctor = val.constructor?.name ?? "TypedArray";
+      const byteLength = val.byteLength ?? "?";
+      return `[${ctor} byteLength=${byteLength}]`;
+    }
+    if (val instanceof ArrayBuffer) {
+      return `[ArrayBuffer byteLength=${val.byteLength}]`;
+    }
+    const cleaned = {};
+    const entries = Object.entries(val);
+    let keyCount = 0;
+    for (const [key, v] of entries) {
+      if (keysToStrip.has(key)) {
+        continue;
+      }
+      if (keyCount >= maxObjectKeys) {
+        cleaned["__truncated"] = `${entries.length - keyCount} more keys omitted`;
+        break;
+      }
+      try {
+        cleaned[key] = helper(v, depth + 1);
+        keyCount++;
+      } catch (error) {
+        cleaned[key] = `[${error instanceof Error ? error.message : String(error)}]`;
+        keyCount++;
+      }
+    }
+    return cleaned;
+  }
+  return helper(value, 0);
+}
+
 // src/spans/base.ts
 function isSpanInternal(spanType, flags) {
   if (flags === void 0 || flags === InternalSpans.NONE) {
@@ -5511,6 +5649,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) {
@@ -5525,6 +5669,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 {
@@ -5578,6 +5725,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,
@@ -5618,49 +5768,6 @@ var BaseSpan = class {
     return fn();
   }
 };
-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]";
-  }
-  if (value === null || typeof value !== "object") {
-    try {
-      JSON.stringify(value);
-      return value;
-    } catch (error) {
-      return `[${error instanceof Error ? error.message : String(error)}]`;
-    }
-  }
-  if (_seen.has(value)) {
-    return "[Circular]";
-  }
-  _seen.add(value);
-  if (value instanceof Date) {
-    return 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;
-    }
-    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;
@@ -6538,6 +6645,6 @@ function buildTracingOptions(...updaters) {
   return updaters.reduce((opts, updater) => updater(opts), {});
 }
 
-export { BaseExporter, BaseObservabilityInstance, BaseSpan, CloudExporter, ConsoleExporter, DefaultExporter, DefaultObservabilityInstance, DefaultSpan, ModelSpanTracker, NoOpSpan, Observability, SamplingStrategyType, SensitiveDataFilter, TestExporter, buildTracingOptions, deepClean, getExternalParentId, observabilityConfigValueSchema, observabilityInstanceConfigSchema, observabilityRegistryConfigSchema, samplingStrategySchema };
+export { BaseExporter, BaseObservabilityInstance, BaseSpan, CloudExporter, ConsoleExporter, DEFAULT_DEEP_CLEAN_OPTIONS, DEFAULT_KEYS_TO_STRIP, DefaultExporter, DefaultObservabilityInstance, DefaultSpan, ModelSpanTracker, NoOpSpan, Observability, SamplingStrategyType, SensitiveDataFilter, TestExporter, buildTracingOptions, deepClean, getExternalParentId, observabilityConfigValueSchema, observabilityInstanceConfigSchema, observabilityRegistryConfigSchema, samplingStrategySchema, truncateString };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map