feat: trace setEmbeddedData at debug level, keys only [ENG-2472]

The bag is otherwise invisible — memory-only, no getter — so a developer
wiring up setEmbeddedData gets no confirmation until a survey happens to
display. Mirrors the js-core trace from formbricks/formbricks#9091: the keys
set and removed, what the bag now holds, and the sentence that pre-empts the
next question ("keys land on a response only if the survey declares them").

Values never reach a log line: the documented use of this bag includes hashed
identity fields. Debug level, which this SDK gates on __DEV__, so a release
build never prints it.

Five tests, one of them the no-values assertion — mutation-checked by making
the trace print values, which turns exactly three of them red.

Author: itsjavi

packages/react-native/src/lib/survey/embedded-data.ts

@@ -60,10 +60,14 @@ export class EmbeddedDataStore {
       return;
     }
 
+    const set: string[] = [];
+    const removed: string[] = [];
+
     for (const [key, value] of Object.entries(data)) {
       if (value === undefined) continue;
       if (value === null) {
         this.data.delete(key);
+        removed.push(key);
         continue;
       }
       // Refused rather than stored: `toISOString()` throws a RangeError on an invalid Date, and
@@ -78,7 +82,17 @@ export class EmbeddedDataStore {
         continue;
       }
       this.data.set(key, value);
+      set.push(key);
     }
+
+    // A success trace, because the bag is otherwise invisible: it lives in memory (nothing in async
+    // storage to inspect) and the API has no getter, so without this line a developer wiring up
+    // `setEmbeddedData` gets zero confirmation until a survey happens to display. Debug level, which
+    // this SDK gates on `__DEV__`, so a release build never prints it. Keys only, never values — the
+    // documented use of this bag includes hashed identity fields.
+    Logger.getInstance().debug(
+      `setEmbeddedData: set [${set.join(", ")}]${removed.length > 0 ? `, removed [${removed.join(", ")}]` : ""} — the bag now holds [${[...this.data.keys()].join(", ")}]. Keys land on a response only if the survey declares them as ingested Embedded Data fields.`,
+    );
   }
 
   /**
@@ -90,7 +104,11 @@ export class EmbeddedDataStore {
    */
   public clearEmbeddedData(...args: [] | [key: string]): void {
     if (args.length === 0) {
+      const clearedCount = this.data.size;
       this.data.clear();
+      Logger.getInstance().debug(
+        `clearEmbeddedData: cleared the whole bag (${String(clearedCount)} keys)`,
+      );
       return;
     }
 
@@ -103,6 +121,9 @@ export class EmbeddedDataStore {
     }
 
     this.data.delete(key);
+    Logger.getInstance().debug(
+      `clearEmbeddedData: removed "${key}" — the bag now holds [${[...this.data.keys()].join(", ")}]`,
+    );
   }
 
   /**

packages/react-native/src/lib/survey/tests/embedded-data.test.ts

@@ -1,9 +1,14 @@
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { EmbeddedDataStore } from "@/lib/survey/embedded-data";
 
-// The guards log through Logger; mocked so refused inputs don't spray the test output.
+const { mockLogger } = vi.hoisted(() => ({
+  mockLogger: { error: vi.fn(), debug: vi.fn() },
+}));
+
+// The guards log errors and the success trace logs at debug; mocked so refused inputs don't spray
+// the test output, and a stable instance lets the trace tests below assert on what was written.
 vi.mock("@/lib/common/logger", () => ({
-  Logger: { getInstance: vi.fn(() => ({ error: vi.fn(), debug: vi.fn() })) },
+  Logger: { getInstance: vi.fn(() => mockLogger) },
 }));
 
 type TSetInput = Parameters<EmbeddedDataStore["setEmbeddedData"]>[0];
@@ -166,3 +171,67 @@ describe("input guards (never fatal)", () => {
     expect(store.getSnapshot()).toEqual({ plan: "pro", screen: "product" });
   });
 });
+
+describe("the debug success trace — the bag's only success feedback", () => {
+  let store: EmbeddedDataStore;
+
+  beforeEach(() => {
+    store = EmbeddedDataStore.getInstance();
+    store.clearEmbeddedData();
+    mockLogger.debug.mockClear();
+  });
+
+  test("a successful set logs the keys it set and what the bag now holds — keys only, never values", () => {
+    store.setEmbeddedData({ plan: "pro", hashed_email: "s3cret-hash" });
+
+    expect(mockLogger.debug).toHaveBeenCalledTimes(1);
+    const message = mockLogger.debug.mock.calls[0][0] as string;
+    expect(message).toContain("set [plan, hashed_email]");
+    expect(message).toContain("the bag now holds [plan, hashed_email]");
+    // The bag's documented use includes hashed identity fields; values must never reach a log line.
+    expect(message).not.toContain("pro");
+    expect(message).not.toContain("s3cret-hash");
+  });
+
+  test("a null removal shows up in the trace as removed, not set", () => {
+    store.setEmbeddedData({ plan: "pro" });
+    mockLogger.debug.mockClear();
+
+    store.setEmbeddedData({ plan: null, screen: "product" });
+
+    const message = mockLogger.debug.mock.calls[0][0] as string;
+    expect(message).toContain("set [screen]");
+    expect(message).toContain("removed [plan]");
+    expect(message).toContain("the bag now holds [screen]");
+  });
+
+  test("a skipped invalid Date appears in neither list, and its value never reaches the log", () => {
+    store.setEmbeddedData({ plan: "pro", signedUpAt: new Date("nope") });
+
+    const message = mockLogger.debug.mock.calls[0][0] as string;
+    expect(message).toContain("set [plan]");
+    expect(message).not.toContain("signedUpAt");
+  });
+
+  test("clearEmbeddedData traces both forms", () => {
+    store.setEmbeddedData({ plan: "pro", screen: "product" });
+    mockLogger.debug.mockClear();
+
+    store.clearEmbeddedData("plan");
+    expect(mockLogger.debug.mock.calls[0][0]).toContain('removed "plan"');
+
+    store.clearEmbeddedData();
+    expect(mockLogger.debug.mock.calls[1][0]).toContain(
+      "cleared the whole bag (1 keys)",
+    );
+  });
+
+  test("a refused input logs an error and no success trace", () => {
+    mockLogger.error.mockClear();
+
+    store.setEmbeddedData(null as unknown as TSetInput);
+
+    expect(mockLogger.error).toHaveBeenCalledTimes(1);
+    expect(mockLogger.debug).not.toHaveBeenCalled();
+  });
+});