@mastra/observability 1.17.5-alpha.2 → 1.17.6-alpha.0

package/dist/index.cjs

@@ -1792,7 +1792,38 @@ function getProvidedCostContext(attrs, usage) {
 	});
 	return contexts;
 }
+/**
+* Entity types the processor runner assigns to the spans it creates, one per
+* pipeline phase.
+*/
+const PROCESSOR_ENTITY_TYPES = /* @__PURE__ */ new Set([
+	_mastra_core_observability.EntityType.INPUT_PROCESSOR,
+	_mastra_core_observability.EntityType.INPUT_STEP_PROCESSOR,
+	_mastra_core_observability.EntityType.OUTPUT_PROCESSOR,
+	_mastra_core_observability.EntityType.OUTPUT_STEP_PROCESSOR,
+	_mastra_core_observability.EntityType.TOOL_RESULT_PROCESSOR
+]);
+/**
+* Whether this span measures a processor running, for `mastra_processor_duration_ms`.
+*
+* A processor may declare a domain span type (e.g. the skills processor emits
+* `SKILL_ACTION`), so `PROCESSOR_RUN` alone no longer identifies one. A
+* processor entity type alone is not enough either: spans that are not
+* processors borrow one — observational memory wraps its observer and reflector
+* model calls in a `GENERIC` span tagged `OUTPUT_STEP_PROCESSOR`, and counting
+* those model-call durations would swamp a metric measuring processor overhead.
+*
+* So require the pipeline attribute the runner stamps on every processor span
+* it creates ('legacy' from the runner, 'workflow' from processor workflows),
+* which spans merely borrowing the entity type do not set.
+*/
+function isProcessorSpan(span) {
+	if (!span.entityType || !PROCESSOR_ENTITY_TYPES.has(span.entityType)) return false;
+	if (span.type === _mastra_core_observability.SpanType.PROCESSOR_RUN) return true;
+	return Boolean(span.attributes?.processorExecutor);
+}
 function getDurationMetricName(span) {
+	if (isProcessorSpan(span)) return "mastra_processor_duration_ms";
 	switch (span.type) {
 		case _mastra_core_observability.SpanType.AGENT_RUN: return "mastra_agent_duration_ms";
 		case _mastra_core_observability.SpanType.TOOL_CALL:
@@ -2851,6 +2882,8 @@ var BaseSpan = class BaseSpan {
 	correlationContext;
 	/** Child spans that have started but not yet ended */
 	#openChildren;
+	/** The span whose open-child set currently tracks this span: the parent, or a live ancestor after promotion */
+	#openChildrenOwner;
 	/**
 	* Subclasses can override to unconditionally mark the span as excluded.
 	* NoOpSpan uses this because it is never exported regardless of config.
@@ -2873,7 +2906,10 @@ var BaseSpan = class BaseSpan {
 		this.tracingPolicy = options.tracingPolicy;
 		this.traceState = options.traceState;
 		const parent = options.parent;
-		if (!this.isEvent && parent instanceof BaseSpan && parent.isValid) (parent.#openChildren ??= /* @__PURE__ */ new Set()).add(this);
+		if (!this.isEvent && parent instanceof BaseSpan && parent.isValid) {
+			(parent.#openChildren ??= /* @__PURE__ */ new Set()).add(this);
+			this.#openChildrenOwner = parent;
+		}
 		this.tags = !options.parent && options.tags?.length ? options.tags : void 0;
 		const entityParent = this.getParentSpan(false);
 		this.entityType = options.entityType ?? entityParent?.entityType;
@@ -2916,10 +2952,34 @@ var BaseSpan = class BaseSpan {
 		if (this.#openChildren) for (const child of [...this.#openChildren]) child.endTree(options);
 		this.end(options);
 	}
-	/** Release this span from its parent's open-child set once it has ended */
+	/** Close any still-open descendant spans without applying options to them */
+	endOpenDescendants() {
+		if (this.#openChildren) for (const child of [...this.#openChildren]) child.endTree();
+	}
+	/**
+	* Release this span from its parent's open-child set once it has ended.
+	* Children still open at that moment are handed to the nearest ancestor
+	* that has not ended, so a later endTree() on that ancestor can still
+	* reach them (e.g. a model span that finalizes on abort before the
+	* agent run's terminal handler closes the tree).
+	*/
 	detachFromParent() {
-		const parent = this.parent;
-		if (parent instanceof BaseSpan) parent.#openChildren?.delete(this);
+		const owner = this.#openChildrenOwner;
+		if (owner) {
+			owner.#openChildren?.delete(this);
+			this.#openChildrenOwner = void 0;
+		}
+		if (this.#openChildren?.size) {
+			let ancestor = this.parent;
+			while (ancestor instanceof BaseSpan && ancestor.endTime) ancestor = ancestor.parent;
+			if (ancestor instanceof BaseSpan) {
+				for (const child of this.#openChildren) {
+					(ancestor.#openChildren ??= /* @__PURE__ */ new Set()).add(child);
+					child.#openChildrenOwner = ancestor;
+				}
+				this.#openChildren.clear();
+			}
+		}
 	}
 	createChildSpan(options) {
 		return this.observabilityInstance.startSpan({
@@ -3142,6 +3202,7 @@ var DefaultSpan = class extends BaseSpan {
 	end(options) {
 		if (this.isEvent) return;
 		if (this.endTime) return;
+		if (options?.endTree) this.endOpenDescendants();
 		this.endTime = /* @__PURE__ */ new Date();
 		this.detachFromParent();
 		if (options?.metadata) this.metadata = {
@@ -3157,7 +3218,7 @@ var DefaultSpan = class extends BaseSpan {
 	}
 	error(options) {
 		if (this.isEvent) return;
-		const { error, endSpan = true, attributes, metadata } = options;
+		const { error, endSpan = true, endTree, attributes, metadata } = options;
 		if (metadata) this.metadata = {
 			...this.metadata,
 			...deepClean(this.prepareSpanMetadata(metadata), this.deepCleanOptions)
@@ -3181,7 +3242,8 @@ var DefaultSpan = class extends BaseSpan {
 				...deepClean(attributes, this.deepCleanOptions)
 			};
 		}
-		if (endSpan) this.end();
+		if (endTree) this.end({ endTree: true });
+		else if (endSpan) this.end();
 		else this.update({});
 	}
 	update(options) {