@hyperframes/studio 0.7.89 → 0.7.92

package/src/utils/studioTelemetry.test.ts

@@ -0,0 +1,76 @@
+// @vitest-environment happy-dom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// The `studio:*` path predates telemetry/config.ts and shipped its own
+// opt-out key and its own send loop, so it sat outside both contracts the
+// canary work established: the documented opt-out did not silence it, and its
+// events carried no cohort assignment. These pin both.
+
+vi.mock("../telemetry/canary", () => ({
+  canaryEventProperties: () => ({ "$feature/canary-test-one": "true" }),
+}));
+
+// One shared policy now governs this transport, telemetry/client.ts and
+// canary enrolment. Exercised directly here so each case names the control
+// under test rather than relying on ambient import.meta.env.
+const policyState = { allowed: true };
+vi.mock("../telemetry/policy", () => ({
+  browserTelemetryAllowed: () => policyState.allowed,
+}));
+
+describe("studioTelemetry — shared opt-out and canary properties", () => {
+  let trackStudioEvent: typeof import("./studioTelemetry").trackStudioEvent;
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(async () => {
+    policyState.allowed = true;
+    localStorage.clear();
+    vi.resetModules();
+    vi.useFakeTimers();
+    fetchMock = vi.fn(() => Promise.resolve({ ok: true } as Response));
+    vi.stubGlobal("fetch", fetchMock);
+    ({ trackStudioEvent } = await import("./studioTelemetry"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  /** Drain the queue and return the events the batch would have sent. */
+  async function sentEvents(): Promise<Array<Record<string, unknown>>> {
+    await vi.runOnlyPendingTimersAsync();
+    if (fetchMock.mock.calls.length === 0) return [];
+    const body = fetchMock.mock.calls[0]?.[1] as { body?: string } | undefined;
+    const parsed = JSON.parse(body?.body ?? "{}") as { batch?: Array<Record<string, unknown>> };
+    return parsed.batch ?? [];
+  }
+
+  // Every control the shared policy enforces — documented key, legacy key,
+  // navigator.doNotTrack, VITE_HYPERFRAMES_NO_TELEMETRY, Vite dev mode, API
+  // key eligibility. Before the policy was shared this transport honoured
+  // only the legacy key, so all of the others still emitted `studio:*`.
+  it("sends nothing when the shared policy refuses", async () => {
+    policyState.allowed = false;
+    trackStudioEvent("thing_happened");
+    expect(await sentEvents()).toHaveLength(0);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("attaches canary assignments to every event", async () => {
+    trackStudioEvent("thing_happened");
+    const events = await sentEvents();
+    expect(events).toHaveLength(1);
+    expect(events[0]?.["properties"]).toMatchObject({
+      "$feature/canary-test-one": "true",
+    });
+  });
+
+  it("lets an explicit property win over the canary mixin", async () => {
+    trackStudioEvent("thing_happened", { "$feature/canary-test-one": "false" });
+    const events = await sentEvents();
+    expect(events[0]?.["properties"]).toMatchObject({
+      "$feature/canary-test-one": "false",
+    });
+  });
+});

package/src/utils/studioTelemetry.ts

@@ -1,4 +1,6 @@
 import { resolveStudioDistinctId } from "../telemetry/distinctId";
+import { browserTelemetryAllowed } from "../telemetry/policy";
+import { canaryEventProperties } from "../telemetry/canary";
 
 // PostHog public ingest key — write-only, safe to ship in the client bundle
 const POSTHOG_API_KEY = "phc_zjjbX0PnWxERXrMHhkEJWj9A9BhGVLRReICgsfTMmpx";
@@ -26,12 +28,15 @@ function getDistinctId(): string {
   return resolveStudioDistinctId();
 }
 
+/**
+ * This path predates telemetry/config.ts and enforced only its own
+ * localStorage key, so `navigator.doNotTrack`, VITE_HYPERFRAMES_NO_TELEMETRY,
+ * Vite dev mode and the documented `hyperframes-studio:telemetryDisabled` all
+ * failed to silence `studio:*` events. Now one shared policy governs every
+ * transport — including the legacy key, which it still honours.
+ */
 function isEnabled(): boolean {
-  try {
-    return localStorage.getItem("hf-studio-telemetry-opt-out") !== "1";
-  } catch {
-    return true;
-  }
+  return browserTelemetryAllowed();
 }
 
 function getSessionProperties(): EventProperties {
@@ -56,7 +61,10 @@ export function trackStudioEvent(event: string, properties: EventProperties = {}
 
   queue.push({
     event: `studio:${event}`,
-    properties: { ...getSessionProperties(), ...properties },
+    // Canary assignments on every event, matching the CLI and the newer
+    // studio client — "every telemetry event carries the assignment" has to
+    // include this path or a cohort breakdown silently omits `studio:*`.
+    properties: { ...getSessionProperties(), ...canaryEventProperties(), ...properties },
     timestamp: new Date().toISOString(),
   });