@mastra/observability 1.16.5 → 1.16.6-alpha.2

package/dist/index.js

@@ -1759,6 +1759,34 @@ function addUsageStats(a, b) {
 function supportsModelInference() {
 	return coreFeatures.has("model-inference-span");
 }
+function parseGatewayCost(providerMetadata) {
+	const rawCost = providerMetadata?.gateway?.cost;
+	const cost = typeof rawCost === "number" ? rawCost : typeof rawCost === "string" && rawCost.trim().length > 0 ? Number(rawCost) : void 0;
+	return typeof cost === "number" && Number.isFinite(cost) && cost >= 0 ? cost : void 0;
+}
+function getGatewayCostContext({ stepProviderMetadata }) {
+	if (!stepProviderMetadata) return;
+	if (!stepProviderMetadata.some((metadata) => metadata?.gateway !== void 0)) return;
+	const costs = [];
+	for (const metadata of stepProviderMetadata) {
+		const cost = parseGatewayCost(metadata);
+		if (cost === void 0) return;
+		costs.push(cost);
+	}
+	const estimatedCost = costs.reduce((total, cost) => total + cost, 0);
+	if (!Number.isFinite(estimatedCost)) return;
+	return {
+		estimatedCost,
+		costUnit: "USD",
+		costMetadata: {
+			source: "provider_reported",
+			sdkProvider: "vercel_ai_gateway",
+			sdkCostField: "gateway.cost",
+			scope: "query_total",
+			reportedStepCount: costs.length
+		}
+	};
+}
 function formatPreviewLabel(label, fallback) {
 	return typeof label === "string" && label.length > 0 ? label : fallback;
 }
@@ -1940,10 +1968,11 @@ var ModelSpanTracker = class {
 	* If usage is provided, it will be converted to UsageStats with cache token details.
 	*/
 	endGeneration(options) {
-		const { usage, providerMetadata, ...spanOptions } = options ?? {};
+		const { usage, providerMetadata, stepProviderMetadata, ...spanOptions } = options ?? {};
 		if (spanOptions.attributes) {
 			spanOptions.attributes.completionStartTime = this.#completionStartTime;
 			spanOptions.attributes.usage = extractUsageMetrics(usage, providerMetadata);
+			if (!spanOptions.attributes.costContext) spanOptions.attributes.costContext = getGatewayCostContext({ stepProviderMetadata });
 		}
 		this.#modelSpan?.end(spanOptions);
 	}
@@ -2431,12 +2460,12 @@ function isSpanInternal(spanType, flags) {
 /**
 * Get the external parent span ID from CreateSpanOptions.
 *
-* If the parent is internal, walks up the parent chain to find
-* the closest external ancestor. If the parent is already external,
-* returns its ID directly.
+* If the parent is internal or excluded from export (`excludeSpanTypes`),
+* walks up the parent chain to find the closest exported ancestor.
+* If the parent is already exportable, returns its ID directly.
 *
 * This is useful when exporting spans to external observability systems
-* that shouldn't include internal framework spans.
+* that shouldn't include internal framework spans or excluded types.
 *
 * @param options - Span creation options
 * @returns The external parent span ID, or undefined if no external parent exists
@@ -2457,8 +2486,9 @@ function isSpanInternal(spanType, flags) {
 */
 function getExternalParentId(options) {
 	if (!options.parent) return;
-	if (options.parent.isInternal) return options.parent.getParentSpanId(false);
-	else return options.parent.id;
+	const parent = options.parent;
+	if (parent.isInternal || parent.isExcluded) return parent.getParentSpanId(false);
+	return parent.id;
 }
 var BaseSpan = class {
 	name;
@@ -2497,6 +2527,10 @@ var BaseSpan = class {
 	* when the span is internal and includeInternalSpans is false, or when
 	* the subclass is always excluded (e.g., NoOpSpan).
 	*
+	* Public so parent-chain walks (`getParentSpan`) can skip ancestors that
+	* exporters will never receive — otherwise descendants export a
+	* `parentSpanId` pointing at a dropped span and become orphans.
+	*
 	* Note: metadata is still attached and deepCleaned because it is read in
 	* process by getCorrelationContext() and by getLoggerContext() /
 	* getMetricsContext() (which structuredClone it).
@@ -2568,14 +2602,20 @@ var BaseSpan = class {
 	get isRootSpan() {
 		return !this.parent;
 	}
-	/** Get the closest parent span, optionally skipping internal spans */
+	/**
+	* Get the closest parent span.
+	* Always skips ancestors dropped by `excludeSpanTypes` (`isExcluded`), so
+	* exported `parentSpanId` values never point at spans exporters omit.
+	* When `includeInternalSpans` is false/undefined, also skips `isInternal`
+	* ancestors.
+	*/
 	getParentSpan(includeInternalSpans) {
 		if (!this.parent) return;
-		if (includeInternalSpans) return this.parent;
-		if (this.parent.isInternal) return this.parent.getParentSpan(includeInternalSpans);
+		const parent = this.parent;
+		if (parent.isExcluded || !includeInternalSpans && parent.isInternal) return parent.getParentSpan(includeInternalSpans);
 		return this.parent;
 	}
-	/** Get the closest parent spanId that isn't an internal span */
+	/** Get the closest parent spanId that will reach exporters (unless includeInternalSpans) */
 	getParentSpanId(includeInternalSpans) {
 		if (!this.parent) return this.parentSpanId;
 		const parentSpan = this.getParentSpan(includeInternalSpans);
@@ -8696,6 +8736,23 @@ function isInstance(obj) {
 	return obj instanceof BaseObservabilityInstance;
 }
 /**
+* Delays (ms) between attempts to rehydrate a trace from storage when an
+* annotation (score/feedback) targets a span that has not been flushed by
+* the configured exporters yet. Exporters buffer and flush asynchronously:
+* by default they flush at 1000 spans or after a 5000ms wait
+* (`maxBatchWaitMs`), so an annotation emitted right after a span ends can
+* race the flush and be silently dropped. The schedule below sums to
+* ~5.85s, covering the default flush interval with margin.
+*/
+const RECORDED_TRACE_LOOKUP_RETRY_DELAYS_MS = [
+	100,
+	250,
+	500,
+	1e3,
+	2e3,
+	2e3
+];
+/**
 * Top-level observability entrypoint. Manages a registry of ObservabilityInstance
 * configurations and provides instance selection via config selectors.
 */
@@ -8852,14 +8909,15 @@ var Observability = class extends MastraBase {
 			return;
 		}
 		if (!args.traceId) return;
-		const trace = await this.#getStoredTrace(args.traceId);
-		if (!trace) return;
-		const event = buildRecordedScoreEventFromTrace({
+		const event = await this.#buildRecordedEventWithRetry(args.traceId, (trace) => buildRecordedScoreEventFromTrace({
 			trace,
 			spanId: args.spanId,
 			score: args.score
-		});
-		if (!event) return;
+		}));
+		if (!event) {
+			this.logger?.warn(`Score event was dropped because the target trace/span was not found in observability storage (traceId: ${args.traceId}, spanId: ${args.spanId})`);
+			return;
+		}
 		await this.#emitRecordedEvent(event);
 	}
 	async addFeedback(args) {
@@ -8875,14 +8933,15 @@ var Observability = class extends MastraBase {
 			return;
 		}
 		if (!args.traceId) return;
-		const trace = await this.#getStoredTrace(args.traceId);
-		if (!trace) return;
-		const event = buildRecordedFeedbackEventFromTrace({
+		const event = await this.#buildRecordedEventWithRetry(args.traceId, (trace) => buildRecordedFeedbackEventFromTrace({
 			trace,
 			spanId: args.spanId,
 			feedback: args.feedback
-		});
-		if (!event) return;
+		}));
+		if (!event) {
+			this.logger?.warn(`Feedback event was dropped because the target trace/span was not found in observability storage (traceId: ${args.traceId}, spanId: ${args.spanId})`);
+			return;
+		}
 		await this.#emitRecordedEvent(event);
 	}
 	/** Register a named observability instance, optionally marking it as default. */
@@ -8947,6 +9006,20 @@ var Observability = class extends MastraBase {
 		if (!storage) return null;
 		return await storage.getStore("observability") ?? null;
 	}
+	/**
+	* Build a recorded score/feedback event from storage, retrying briefly to
+	* ride out the async exporter flush: annotations emitted right after a
+	* span ends can otherwise race the flush and be silently dropped.
+	*/
+	async #buildRecordedEventWithRetry(traceId, build) {
+		for (const delayMs of [0, ...RECORDED_TRACE_LOOKUP_RETRY_DELAYS_MS]) {
+			if (delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+			const trace = await this.#getStoredTrace(traceId);
+			const event = trace ? build(trace) : null;
+			if (event) return event;
+		}
+		return null;
+	}
 	async #getStoredTrace(traceId) {
 		const observabilityStorage = await this.#getObservabilityStorage();
 		if (!observabilityStorage) return null;