@mastra/observability 1.17.1-alpha.1 → 1.17.1

package/dist/index.js

@@ -192,6 +192,12 @@ const LOGGER_METHODS = [
 	"warn",
 	"error"
 ];
+/** Keys whose value decides the outcome in `shouldStripEntry()`. */
+const VALUE_STRIP_KEYS = /* @__PURE__ */ new Set([
+	"logger",
+	"tracingContext",
+	...FUNCTION_KEYS_TO_STRIP
+]);
 const DEFAULT_DEEP_CLEAN_OPTIONS = Object.freeze({
 	keysToStrip: [],
 	maxDepth: 8,
@@ -273,6 +279,25 @@ function shouldStripEntry(key, value, stripSet) {
 	if (key === "logger") return typeof value === "function" || isLoggerLike(value);
 	return FUNCTION_KEYS_TO_STRIP.has(key) && typeof value === "function";
 }
+/**
+* Whether an entry past the object-key limit would have been stripped anyway.
+*
+* The entry is dropped either way, so the value is taken from its property descriptor
+* rather than read: a getter must not run for data that is being discarded. That keeps
+* the truncation count the same wherever a runtime-shaped key sits. An accessor cannot
+* be classified without invoking it, so it is left to the limit and counted.
+*/
+function wouldBeStripped(key, val, stripSet) {
+	if (!VALUE_STRIP_KEYS.has(key)) return false;
+	let descriptor;
+	try {
+		descriptor = Object.getOwnPropertyDescriptor(val, key);
+	} catch {
+		return false;
+	}
+	if (!descriptor || !("value" in descriptor)) return false;
+	return shouldStripEntry(key, descriptor.value, stripSet);
+}
 function restoreSerializedMapKey(keyType, key) {
 	switch (keyType) {
 		case "undefined": return;
@@ -458,25 +483,22 @@ function deepClean(value, options = DEFAULT_DEEP_CLEAN_OPTIONS) {
 				return formatSerializationError(error);
 			}
 			let keyCount = 0;
+			let omittedByLimit = 0;
 			for (const key of keys) {
 				if (stripSet.has(key)) continue;
+				if (keyCount >= maxObjectKeys) {
+					if (!wouldBeStripped(key, val, stripSet)) omittedByLimit++;
+					continue;
+				}
 				let rawValue;
 				try {
 					rawValue = val[key];
 				} catch (error) {
-					if (keyCount >= maxObjectKeys) {
-						cleaned["__truncated"] = `${keys.length - keyCount} more keys omitted`;
-						break;
-					}
 					cleaned[key] = formatSerializationError(error);
 					keyCount++;
 					continue;
 				}
 				if (shouldStripEntry(key, rawValue, stripSet)) continue;
-				if (keyCount >= maxObjectKeys) {
-					cleaned["__truncated"] = `${keys.length - keyCount} more keys omitted`;
-					break;
-				}
 				try {
 					cleaned[key] = helper(rawValue, depth + 1);
 					keyCount++;
@@ -485,6 +507,7 @@ function deepClean(value, options = DEFAULT_DEEP_CLEAN_OPTIONS) {
 					keyCount++;
 				}
 			}
+			if (omittedByLimit > 0) cleaned["__truncated"] = `${omittedByLimit} more keys omitted`;
 			return cleaned;
 		} finally {
 			if (typeof val === "object" && val !== null) ancestors.delete(val);