@mastra/observability 1.9.2-alpha.0 → 1.10.0-alpha.2

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @mastra/observability
 
+## 1.10.0-alpha.2
+
+### Minor Changes
+
+- Changed `MODEL_CHUNK` `tool-result` span `output` handling. ([#15495](https://github.com/mastra-ai/mastra/pull/15495))
+
+  **What changed**
+  - `MODEL_CHUNK` spans for `tool-result` now omit `output` for locally executed tools.
+  - `TOOL_CALL` remains the canonical span for locally executed tool result payloads.
+  - `MODEL_CHUNK` spans for provider-executed `tool-result` chunks still include `output`.
+  - `MODEL_CHUNK` metadata still includes `toolCallId`, `toolName`, and `providerExecuted`.
+
+  **Why**
+  This reduces duplicate tool result payloads in traces without dropping provider-emitted tool results that may not have a matching `TOOL_CALL` span.
+
+### Patch Changes
+
+- Updated dependencies [[`8786a61`](https://github.com/mastra-ai/mastra/commit/8786a61fa54ba265f85eeff9985ca39863d18bb6), [`8fb2405`](https://github.com/mastra-ai/mastra/commit/8fb2405138f2d208b7962ad03f121ca25bcc28c5)]:
+  - @mastra/core@1.26.0-alpha.7
+
+## 1.9.2-alpha.1
+
+### Patch Changes
+
+- Improved tracing overhead when filtering spans. Spans dropped by `excludeSpanTypes` or the internal-span filter (`includeInternalSpans: false`) now skip payload serialization and retention entirely instead of paying the cost and discarding at export time. ([#15487](https://github.com/mastra-ai/mastra/pull/15487))
+
+- Updated dependencies [[`6315317`](https://github.com/mastra-ai/mastra/commit/63153175fe9a7b224e5be7c209bbebc01dd9b0d5), [`9d3b24b`](https://github.com/mastra-ai/mastra/commit/9d3b24b19407ae9c09586cf7766d38dc4dff4a69)]:
+  - @mastra/core@1.26.0-alpha.6
+
 ## 1.9.2-alpha.0
 
 ### Patch Changes

package/dist/index.cjs

@@ -19152,14 +19152,16 @@ var ModelSpanTracker = class {
                 dynamic,
                 providerExecuted,
                 providerMetadata,
-                // Output - the actual result
+                // Keep provider-executed results on MODEL_CHUNK because they come
+                // from the model/provider stream and may not have a sibling TOOL_CALL span.
+                // For locally executed tools, the canonical payload lives on TOOL_CALL.
                 result} = chunk.payload || {};
               const metadata = { toolCallId, toolName };
               if (isError !== void 0) metadata.isError = isError;
               if (dynamic !== void 0) metadata.dynamic = dynamic;
               if (providerExecuted !== void 0) metadata.providerExecuted = providerExecuted;
               if (providerMetadata !== void 0) metadata.providerMetadata = providerMetadata;
-              this.#createEventSpan(chunk.type, result, { metadata });
+              this.#createEventSpan(chunk.type, providerExecuted ? result : void 0, { metadata });
               break;
             }
           }
@@ -19239,32 +19241,58 @@ var BaseSpan = class {
   parentSpanId;
   /** Deep clean options for serialization */
   deepCleanOptions;
+  /**
+   * Whether this span is filtered out before export. When true, BaseSpan/
+   * DefaultSpan skip attaching attributes/input/output/errorInfo/requestContext
+   * entirely -- they are never read on excluded spans, and skipping avoids
+   * both the deepClean cost and holding references to large payloads for
+   * the lifetime of the span. Set when excludeSpanTypes drops the type,
+   * when the span is internal and includeInternalSpans is false, or when
+   * the subclass is always excluded (e.g., NoOpSpan).
+   *
+   * Note: metadata is still attached and deepCleaned because it is read in
+   * process by getCorrelationContext() and by getLoggerContext() /
+   * getMetricsContext() (which structuredClone it).
+   */
+  isExcluded;
   /** Cached canonical correlation context for this live span */
   correlationContext;
+  /**
+   * Subclasses can override to unconditionally mark the span as excluded.
+   * NoOpSpan uses this because it is never exported regardless of config.
+   */
+  get alwaysExcluded() {
+    return false;
+  }
   constructor(options, observabilityInstance) {
-    const serializationOptions = observabilityInstance.getConfig().serializationOptions;
-    this.deepCleanOptions = mergeSerializationOptions(serializationOptions);
+    const observabilityConfig = observabilityInstance.getConfig();
+    this.deepCleanOptions = mergeSerializationOptions(observabilityConfig.serializationOptions);
     this.name = options.name;
     this.type = options.type;
-    this.attributes = deepClean(options.attributes, this.deepCleanOptions) || {};
+    this.isInternal = isSpanInternal(this.type, options.tracingPolicy?.internal);
+    this.isExcluded = this.alwaysExcluded || observabilityConfig.excludeSpanTypes?.includes(this.type) === true || this.isInternal && !observabilityConfig.includeInternalSpans;
     this.metadata = deepClean(
       options.parent?.metadata || options.metadata ? { ...options.parent?.metadata, ...options.metadata } : void 0,
       this.deepCleanOptions
     );
-    if (options.requestContext && options.requestContext.size() > 0) {
-      this.requestContext = deepClean(options.requestContext.all, this.deepCleanOptions);
-    }
     this.parent = options.parent;
     this.startTime = options.startTime ?? /* @__PURE__ */ new Date();
     this.observabilityInstance = observabilityInstance;
     this.isEvent = options.isEvent ?? false;
-    this.isInternal = isSpanInternal(this.type, options.tracingPolicy?.internal);
     this.traceState = options.traceState;
     this.tags = !options.parent && options.tags?.length ? options.tags : void 0;
     const entityParent = this.getParentSpan(false);
     this.entityType = options.entityType ?? entityParent?.entityType;
     this.entityId = options.entityId ?? entityParent?.entityId;
     this.entityName = options.entityName ?? entityParent?.entityName;
+    if (this.isExcluded) {
+      this.attributes = {};
+      return;
+    }
+    this.attributes = deepClean(options.attributes, this.deepCleanOptions) || {};
+    if (options.requestContext && options.requestContext.size() > 0) {
+      this.requestContext = deepClean(options.requestContext.all, this.deepCleanOptions);
+    }
     if (this.isEvent) {
       this.output = deepClean(options.output, this.deepCleanOptions);
     } else {
@@ -19468,46 +19496,51 @@ var DefaultSpan = class extends BaseSpan {
       return;
     }
     this.endTime = /* @__PURE__ */ new Date();
+    if (options?.metadata) {
+      this.metadata = { ...this.metadata, ...deepClean(options.metadata, this.deepCleanOptions) };
+    }
+    if (this.isExcluded) {
+      return;
+    }
     if (options?.output !== void 0) {
       this.output = deepClean(options.output, this.deepCleanOptions);
     }
     if (options?.attributes) {
       this.attributes = { ...this.attributes, ...deepClean(options.attributes, this.deepCleanOptions) };
     }
-    if (options?.metadata) {
-      this.metadata = { ...this.metadata, ...deepClean(options.metadata, this.deepCleanOptions) };
-    }
   }
   error(options) {
     if (this.isEvent) {
       return;
     }
     const { error: error48, endSpan = true, attributes, metadata } = options;
-    this.errorInfo = deepClean(
-      error48 instanceof error$1.MastraError ? {
-        id: error48.id,
-        details: error48.details,
-        category: error48.category,
-        domain: error48.domain,
-        message: error48.message,
-        name: error48.name,
-        // Prefer the original cause's stack when available. MastraError wraps
-        // thrown errors, so its own stack points to the wrapping site rather
-        // than where the underlying error was thrown.
-        stack: error48.cause instanceof Error && error48.cause.stack || error48.stack
-      } : {
-        message: error48.message,
-        name: error48.name,
-        stack: error48.stack
-      },
-      this.deepCleanOptions
-    );
-    if (attributes) {
-      this.attributes = { ...this.attributes, ...deepClean(attributes, this.deepCleanOptions) };
-    }
     if (metadata) {
       this.metadata = { ...this.metadata, ...deepClean(metadata, this.deepCleanOptions) };
     }
+    if (!this.isExcluded) {
+      this.errorInfo = deepClean(
+        error48 instanceof error$1.MastraError ? {
+          id: error48.id,
+          details: error48.details,
+          category: error48.category,
+          domain: error48.domain,
+          message: error48.message,
+          name: error48.name,
+          // Prefer the original cause's stack when available. MastraError wraps
+          // thrown errors, so its own stack points to the wrapping site rather
+          // than where the underlying error was thrown.
+          stack: error48.cause instanceof Error && error48.cause.stack || error48.stack
+        } : {
+          message: error48.message,
+          name: error48.name,
+          stack: error48.stack
+        },
+        this.deepCleanOptions
+      );
+      if (attributes) {
+        this.attributes = { ...this.attributes, ...deepClean(attributes, this.deepCleanOptions) };
+      }
+    }
     if (endSpan) {
       this.end();
     } else {
@@ -19521,6 +19554,12 @@ var DefaultSpan = class extends BaseSpan {
     if (options.name !== void 0) {
       this.name = options.name;
     }
+    if (options.metadata) {
+      this.metadata = { ...this.metadata, ...deepClean(options.metadata, this.deepCleanOptions) };
+    }
+    if (this.isExcluded) {
+      return;
+    }
     if (options.input !== void 0) {
       this.input = deepClean(options.input, this.deepCleanOptions);
     }
@@ -19530,9 +19569,6 @@ var DefaultSpan = class extends BaseSpan {
     if (options.attributes) {
       this.attributes = { ...this.attributes, ...deepClean(options.attributes, this.deepCleanOptions) };
     }
-    if (options.metadata) {
-      this.metadata = { ...this.metadata, ...deepClean(options.metadata, this.deepCleanOptions) };
-    }
   }
   get isValid() {
     return true;
@@ -19608,6 +19644,10 @@ var NoOpSpan = class extends BaseSpan {
   get isValid() {
     return false;
   }
+  // NoOpSpan is never exported, so treat it as always excluded.
+  get alwaysExcluded() {
+    return true;
+  }
 };
 
 // src/instances/base.ts