fix(runtime-node): report flush failures correctly

packages/runtime-node/src/lifecycle.ts

@@ -203,10 +203,19 @@
 			timer = setTimeout(() => resolve(false), timeoutMs);
 		});
 		const drained = Promise.allSettled(
-			targets.map((target) => target.forceFlush()),
-		).then(() => true);
-		const ok = await Promise.race([drained, timedOut]);
-		clearTimeout(timer);
+			targets.map((target) =>
+				Promise.resolve().then(() => target.forceFlush()),
+			),
+		).then((results) =>
+			results.every((result) => result.status === "fulfilled"),
+		);
+
+		let ok: boolean;
+		try {
+				ok = await Promise.race([drained, timedOut]);
+		} finally {
+			clearTimeout(timer);
+		}
 		if (ok) {
 			telemetryStats.markAllFlushed();
 			if (log) {

packages/runtime-node/src/redact.ts

@@ -131,22 +131,46 @@
 	return out;
 }
 
-function redactValue(value: unknown, r: CompiledRedactor, depth: number): unknown {
-	if (typeof value === "string") return redactString(value, r);
-	if (Array.isArray(value)) {
-		if (depth <= 0) return value;
-		return value.map((item) => redactValue(item, r, depth - 1));
-	}
-	// Defensive: OTLP attributes are flat, but callers hand us arbitrary
-	// objects — walk one more level so nothing sensitive hides inside.
-	if (typeof value === "object" && value !== null && depth > 0) {
-		const out: Record<string, unknown> = {};
-		for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-			out[k] = isSensitiveKey(k, r) ? r.mask : redactValue(v, r, depth - 1);
-		}
-		return out;
-	}
-	return value;
+function redactValue(
+        value: unknown,
+        r: CompiledRedactor,
+        ancestors: WeakMap<object, object>,
+): unknown {
+        if (typeof value === "string") return redactString(value, r);
+
+        if (Array.isArray(value)) {
+                const existing = ancestors.get(value);
+                if (existing) return existing;
+
+                const out: unknown[] = [];
+                ancestors.set(value, out);
+
+                for (const item of value) {
+                        out.push(redactValue(item, r, ancestors));
+                }
+
+                ancestors.delete(value);
+                return out;
+        }
+
+        if (typeof value === "object" && value !== null) {
+                const existing = ancestors.get(value);
+                if (existing) return existing;
+
+                const out: Record<string, unknown> = {};
+                ancestors.set(value, out);
+
+                for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+                        out[k] = isSensitiveKey(k, r)
+                                ? r.mask
+                                : redactValue(v, r, ancestors);
+                }
+
+                ancestors.delete(value);
+                return out;
+        }
+
+        return value;
 }
 
 function isSensitiveKey(key: string, r: CompiledRedactor): boolean {
@@ -164,21 +188,20 @@
 	options?: RedactOptions,
 ): Attributes {
 	const r = compile(options);
-	return redactWith(attributes, r, 4);
+	return redactWith(attributes, r);
 }
 
 function redactWith(
 	attributes: Attributes | null | undefined,
-	r: CompiledRedactor,
-	maxDepth: number,
+        r: CompiledRedactor,
 ): Attributes {
 	const out: Attributes = {};
 	if (!attributes) return out;
 	for (const [key, value] of Object.entries(attributes)) {
 		if (value === undefined) continue;
 		out[key] = isSensitiveKey(key, r)
 			? r.mask
-			: (redactValue(value, r, maxDepth) as Attributes[string]);
+			: (redactValue(value, r, new WeakMap<object, object>()) as Attributes[string]);
 	}
 	return out;
 }
@@ -194,5 +217,5 @@
 		return (attributes) => ({ ...(attributes ?? {}) });
 	}
 	const r = compile(options === true ? undefined : options);
-	return (attributes) => redactWith(attributes, r, 4);
+	return (attributes) => redactWith(attributes, r);
 }

packages/runtime-node/src/server.ts

@@ -904,15 +904,25 @@
 
 	// Everything that buffers telemetry in-process, reachable as one unit:
 	// auto-flush and the crash monitor push all of these out together
 	// (NodeSDK exposes no forceFlush(), but the processors we handed it do).
 	const flushTarget: FlushTarget = {
 		forceFlush: async () => {
-			await Promise.allSettled([
-				alwaysOnProvider.forceFlush(),
-				mainSpanProcessor.forceFlush(),
-				...(errorTraceBuffer ? [errorTraceBuffer.forceFlush()] : []),
-				metricReader.forceFlush(),
+			const results = await Promise.allSettled([
+				Promise.resolve().then(() => alwaysOnProvider.forceFlush()),
+				Promise.resolve().then(() => mainSpanProcessor.forceFlush()),
+				...(errorTraceBuffer
+					? [Promise.resolve().then(() => errorTraceBuffer.forceFlush())]
+					: []),
+				Promise.resolve().then(() => metricReader.forceFlush()),
 			]);
+
+			const failed = results.find(
+				(result) => result.status === "rejected",
+			);
+
+			if (failed) {
+				throw failed.reason;
+			}
 		},
 	};
 	registerFlushTarget("active-server", flushTarget);

packages/runtime-node/test/lifecycle.test.mjs

@@ -0,0 +1,100 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { installAutterAutoFlush } from "../dist/index.js";
+
+test("flush reports false when a target rejects", async () => {
+  const failingTarget = {
+    forceFlush() {
+      return Promise.reject(new Error("flush failed"));
+    },
+  };
+
+  const handle = installAutterAutoFlush({
+    targets: [failingTarget],
+    log: false,
+    warnOnUnflushedExit: false,
+  });
+
+  const result = await handle.flush("reproduction");
+  handle.dispose();
+
+  assert.equal(result, false);
+});
+
+test("flush reports false when a target throws synchronously", async () => {
+  const failingTarget = {
+    forceFlush() {
+      throw new Error("sync flush failed");
+    },
+  };
+
+  const handle = installAutterAutoFlush({
+    targets: [failingTarget],
+    log: false,
+    warnOnUnflushedExit: false,
+  });
+
+  const result = await handle.flush("sync-throw");
+  handle.dispose();
+
+  assert.equal(result, false);
+});
+
+test("flush reports true when all targets fulfill", async () => {
+  const firstTarget = {
+    forceFlush() {
+      return Promise.resolve();
+    },
+  };
+
+  const secondTarget = {
+    forceFlush() {
+      return Promise.resolve();
+    },
+  };
+
+  const handle = installAutterAutoFlush({
+    targets: [firstTarget, secondTarget],
+    log: false,
+    warnOnUnflushedExit: false,
+  });
+
+  const result = await handle.flush("success");
+  handle.dispose();
+
+  assert.equal(result, true);
+});
+
+test("flush reports false when a built-in-style target propagates an exporter rejection", async () => {
+  const exporter = {
+    forceFlush() {
+      return Promise.reject(new Error("exporter failed"));
+    },
+  };
+
+  const builtInStyleTarget = {
+    async forceFlush() {
+      const results = await Promise.allSettled([
+        exporter.forceFlush(),
+        Promise.resolve(),
+      ]);
+
+      const failed = results.find((result) => result.status === "rejected");
+
+      if (failed) {
+        throw failed.reason;
+      }
+    },
+  };
+
+  const handle = installAutterAutoFlush({
+    targets: [builtInStyleTarget],
+    log: false,
+    warnOnUnflushedExit: false,
+  });
+
+  const result = await handle.flush("built-in-style-rejection");
+  handle.dispose();
+
+  assert.equal(result, false);
+});

packages/runtime-node/test/redact.test.mjs

@@ -124,3 +124,38 @@
 	assert.deepEqual(redactAttributes(), {});
 	assert.deepEqual(redactAttributes(null), {});
 });
+
+test("redacts sensitive keys beyond the nested traversal depth", () => {
+        const out = redactAttributes({
+                context: {
+                        level1: {
+                                level2: {
+                                        level3: {
+                                                level4: {
+                                                        password: "SECRET",
+                                                },
+                                        },
+                                },
+                        },
+                },
+        });
+
+        assert.equal(
+                out.context.level1.level2.level3.level4.password,
+                MASK,
+        );
+});
+
+test("handles circular references without leaking sensitive values", () => {
+        const context = {};
+        const nested = { password: "SECRET", safe: "ok" };
+
+        context.self = context;
+        context.nested = nested;
+
+        const out = redactAttributes({ context });
+
+        assert.equal(out.context.nested.password, MASK);
+        assert.equal(out.context.nested.safe, "ok");
+        assert.equal(out.context.self, out.context);
+});