Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

feat(sdk): migrate analytics events to simple_event schema (#76337)

Mahatthana (Kelvin) Nomsawadib58a926cea68
diff --git a/e2e/test-component/scenarios/embedding-sdk/analytics-component-events.cy.spec.tsx b/e2e/test-component/scenarios/embedding-sdk/analytics-component-events.cy.spec.tsx
index 6536b46e6dc..bbb5587432b 100644
--- a/e2e/test-component/scenarios/embedding-sdk/analytics-component-events.cy.spec.tsx
+++ b/e2e/test-component/scenarios/embedding-sdk/analytics-component-events.cy.spec.tsx
@@ -16,20 +16,15 @@ import { mockAuthProviderAndJwtSignIn } from "e2e/support/helpers/embedding-sdk-
const { ORDERS, ORDERS_ID } = SAMPLE_DATABASE;
-const EMBEDDING_SDK_SCHEMA = "iglu:com.metabase/embedding_sdk/jsonschema/1-0-0";
+const SIMPLE_EVENT_SCHEMA = "iglu:com.metabase/simple_event/jsonschema/1-0-0";
// The SDK tracker posts to /api/analytics-proxy with encodeBase64:false, so the
// Snowplow POST body is plain JSON: { data: [ { ue_pr: "<json>", ... } ] }.
// Each ue_pr is a self-describing unstruct_event whose inner `data` is the
-// embedding_sdk event { component, properties, global }. Pull those out.
+// simple_event payload { event, event_detail }. Pull those out.
type SdkEventData = {
- component: string | null;
- properties: Record<string, unknown> | null;
- global: {
- auth_method: string;
- sdk_version: string | null;
- locale_used: boolean;
- };
+ event: "embedding_sdk_initialized" | "embedding_sdk_component_rendered";
+ event_detail?: string; // JSON string — contains component, properties, global
};
const sdkEventsFromProxyBody = (body: unknown): SdkEventData[] => {
@@ -48,10 +43,21 @@ const sdkEventsFromProxyBody = (body: unknown): SdkEventData[] => {
})
.filter(Boolean)
.map((unstruct) => unstruct.data) // unstruct_event -> { schema, data }
- .filter((selfDescribing) => selfDescribing?.schema === EMBEDDING_SDK_SCHEMA)
+ .filter((selfDescribing) => selfDescribing?.schema === SIMPLE_EVENT_SCHEMA)
.map((selfDescribing) => selfDescribing.data as SdkEventData);
};
+const parseEventDetail = (event: SdkEventData) => {
+ try {
+ return JSON.parse(event.event_detail ?? "{}");
+ } catch {
+ return {};
+ }
+};
+
+const findEventByComponent = (events: SdkEventData[], component: string) =>
+ events.find((event) => parseEventDetail(event).component === component);
+
describe("scenarios > embedding-sdk > analytics — per-mount component events", () => {
beforeEach(() => {
signInAsAdminAndEnableEmbeddingSdk();
@@ -100,21 +106,22 @@ describe("scenarios > embedding-sdk > analytics — per-mount component events",
cy.wait(["@analyticsProxy", "@analyticsProxy"]);
cy.wrap(capturedEvents).should((events: SdkEventData[]) => {
- const componentEvent = events.find(
- (event) => event.component === "StaticQuestion",
- );
+ const componentEvent = findEventByComponent(events, "StaticQuestion");
expect(componentEvent, "StaticQuestion mount event").to.exist;
- expect(componentEvent?.global.auth_method, "auth_method global").to.eq(
+ const detail = parseEventDetail(componentEvent!);
+ expect(detail.global.auth_method, "auth_method in event_detail").to.eq(
"sso",
);
- expect(componentEvent?.global.sdk_version, "sdk_version global").to.be.a(
+ expect(detail.global.sdk_version, "sdk_version in event_detail").to.be.a(
"string",
);
});
cy.wrap(capturedEvents).should((events: SdkEventData[]) => {
- const beacon = events.find((event) => event.component === null);
- expect(beacon, "global init beacon (component: null)").to.exist;
+ const beacon = events.find(
+ (event) => event.event === "embedding_sdk_initialized",
+ );
+ expect(beacon, "global init beacon").to.exist;
});
});
@@ -132,20 +139,20 @@ describe("scenarios > embedding-sdk > analytics — per-mount component events",
cy.wait("@analyticsProxy");
cy.wrap(capturedEvents).should((events: SdkEventData[]) => {
- const interactiveQuestionEvent = events.find(
- (event) => event.component === "InteractiveQuestion",
+ const interactiveQuestionEvent = findEventByComponent(
+ events,
+ "InteractiveQuestion",
);
expect(interactiveQuestionEvent, "InteractiveQuestion mount event").to
.exist;
- expect(
- interactiveQuestionEvent?.properties?.["id_new"],
- "id_new property",
- ).to.eq("true");
+ const detail = parseEventDetail(interactiveQuestionEvent!);
+ expect(detail.properties.id_new, "id_new in event_detail").to.eq("true");
});
cy.wrap(capturedEvents).should((events: SdkEventData[]) => {
- const createQuestionEvent = events.find(
- (event) => event.component === "CreateQuestion",
+ const createQuestionEvent = findEventByComponent(
+ events,
+ "CreateQuestion",
);
expect(createQuestionEvent, "no CreateQuestion event").to.be.undefined;
});
@@ -178,14 +185,16 @@ describe("scenarios > embedding-sdk > analytics — per-mount component events",
cy.wait(["@analyticsProxy", "@analyticsProxy"]);
cy.wrap(capturedEvents).should((events: SdkEventData[]) => {
- const interactiveQuestionEvent = events.find(
- (event) => event.component === "InteractiveQuestion",
+ const interactiveQuestionEvent = findEventByComponent(
+ events,
+ "InteractiveQuestion",
);
expect(interactiveQuestionEvent, "InteractiveQuestion mount event").to
.exist;
- const collectionBrowserEvent = events.find(
- (event) => event.component === "CollectionBrowser",
+ const collectionBrowserEvent = findEventByComponent(
+ events,
+ "CollectionBrowser",
);
expect(collectionBrowserEvent, "CollectionBrowser mount event").to.exist;
});
diff --git a/frontend/src/embedding-sdk-bundle/analytics/component-events.ts b/frontend/src/embedding-sdk-bundle/analytics/component-events.ts
index 9b9813a565e..0c5d3250d91 100644
--- a/frontend/src/embedding-sdk-bundle/analytics/component-events.ts
+++ b/frontend/src/embedding-sdk-bundle/analytics/component-events.ts
@@ -5,16 +5,17 @@ import { getSdkPackageVersion } from "embedding-sdk-shared/lib/get-build-info";
import { useSetting } from "metabase/common/hooks";
import { isEmbeddingEajs, isEmbeddingSdk } from "metabase/embedding-sdk/config";
-import { getSdkAuthMethod, getSdkLocaleUsed, trackSdkEvent } from "./snowplow";
+import {
+ getSdkAuthMethod,
+ getSdkLocaleUsed,
+ trackSdkSimpleEvent,
+} from "./snowplow";
export function useIsTrackingEnabled(): boolean {
// Default false so we don't fire events during the settings-load window for users who opted out.
return useSetting("anon-tracking-enabled") ?? false;
}
-export const EMBEDDING_SDK_SCHEMA =
- "iglu:com.metabase/embedding_sdk/jsonschema/1-0-0";
-
// CreateQuestion is intentionally excluded — it renders InteractiveQuestion with
// questionId="new", which already fires an InteractiveQuestion event (id_new: true).
// CreateQuestion is also deprecated in favour of <InteractiveQuestion questionId="new" />.
@@ -175,9 +176,9 @@ export function useTrackSdkComponentMount<C extends SdkComponentName>(
).map(([key, value]) => [key, value == null ? null : String(value)]),
);
- trackSdkEvent({
- schema: EMBEDDING_SDK_SCHEMA,
- data: {
+ trackSdkSimpleEvent({
+ event: "embedding_sdk_component_rendered",
+ event_detail: JSON.stringify({
component: componentName,
properties: serializedProperties,
global: {
@@ -185,7 +186,7 @@ export function useTrackSdkComponentMount<C extends SdkComponentName>(
sdk_version: sdkVersion,
locale_used: getSdkLocaleUsed(),
},
- },
+ }),
});
// deps are intentionally limited to the two gate flags — fires once when both
// become true, capturing entityId and properties as a snapshot at that moment.
diff --git a/frontend/src/embedding-sdk-bundle/analytics/events.unit.spec.tsx b/frontend/src/embedding-sdk-bundle/analytics/events.unit.spec.tsx
index 0d3837fd416..111c38a7318 100644
--- a/frontend/src/embedding-sdk-bundle/analytics/events.unit.spec.tsx
+++ b/frontend/src/embedding-sdk-bundle/analytics/events.unit.spec.tsx
@@ -1,7 +1,7 @@
// jest.mock is hoisted before imports, so jest.fn() must be defined inline.
// External const refs (like `const mockFoo = jest.fn()`) cause TDZ errors.
-jest.mock("./snowplow", () => ({
- trackSdkEvent: jest.fn(),
+jest.mock("embedding-sdk-bundle/analytics/snowplow", () => ({
+ trackSdkSimpleEvent: jest.fn(),
getSdkAuthMethod: jest.fn(() => "sso"),
getSdkLocaleUsed: jest.fn(() => false),
}));
@@ -11,6 +11,7 @@ jest.mock("embedding-sdk-shared/lib/get-build-info", () => ({
}));
import { renderHookWithProviders } from "__support__/ui";
+import { trackSdkSimpleEvent } from "embedding-sdk-bundle/analytics/snowplow";
import { sdkReducers } from "embedding-sdk-bundle/store";
import { createMockSdkState } from "embedding-sdk-bundle/test/mocks/state";
import { setupSdkState } from "embedding-sdk-bundle/test/server-mocks/sdk-init";
@@ -18,9 +19,8 @@ import { createMockSettings } from "metabase-types/api/mocks";
import type { SdkComponentName } from "./component-events";
import { useTrackSdkComponentMount } from "./component-events";
-import { trackSdkEvent } from "./snowplow";
-const mockTrackSdkEvent = jest.mocked(trackSdkEvent);
+const mockTrackSdkSimpleEvent = jest.mocked(trackSdkSimpleEvent);
// Unique entity IDs per test so the module-level firedKeys Set never causes
// cross-test interference (no jest.resetModules() needed).
@@ -64,34 +64,30 @@ function setup({
}
describe("useTrackSdkComponentMount", () => {
+ const parseLastCallDetail = () =>
+ JSON.parse(mockTrackSdkSimpleEvent.mock.lastCall?.[0].event_detail ?? "{}");
+
beforeEach(() => {
jest.clearAllMocks();
});
it("fires one event when tracking is enabled and tracker is ready", () => {
const entityId = uniqueId();
-
setup({
componentName: "StaticDashboard",
entityId,
properties: { ...STUB_DASHBOARD_PROPS, with_title: true },
});
- expect(mockTrackSdkEvent).toHaveBeenCalledTimes(1);
- expect(mockTrackSdkEvent).toHaveBeenCalledWith(
- expect.objectContaining({
- schema: "iglu:com.metabase/embedding_sdk/jsonschema/1-0-0",
- data: expect.objectContaining({
- component: "StaticDashboard",
- properties: expect.objectContaining({ with_title: "true" }),
- global: {
- auth_method: "sso",
- sdk_version: "1.2.3",
- locale_used: false,
- },
- }),
- }),
+ expect(mockTrackSdkSimpleEvent).toHaveBeenCalledTimes(1);
+ expect(mockTrackSdkSimpleEvent).toHaveBeenCalledWith(
+ expect.objectContaining({ event: "embedding_sdk_component_rendered" }),
);
+ expect(parseLastCallDetail()).toMatchObject({
+ component: "StaticDashboard",
+ properties: { with_title: "true" },
+ global: { auth_method: "sso", sdk_version: "1.2.3", locale_used: false },
+ });
});
it("does not fire when tracking is disabled", () => {
@@ -102,7 +98,7 @@ describe("useTrackSdkComponentMount", () => {
properties: STUB_DASHBOARD_PROPS,
});
- expect(mockTrackSdkEvent).not.toHaveBeenCalled();
+ expect(mockTrackSdkSimpleEvent).not.toHaveBeenCalled();
});
it("does not fire when isTrackingEnabled is true but isTrackerReady is false", () => {
@@ -114,12 +110,11 @@ describe("useTrackSdkComponentMount", () => {
properties: STUB_DASHBOARD_PROPS,
});
- expect(mockTrackSdkEvent).not.toHaveBeenCalled();
+ expect(mockTrackSdkSimpleEvent).not.toHaveBeenCalled();
});
it("deduplicates — re-renders with same key do not re-fire", () => {
const entityId = uniqueId();
-
const { rerender } = setup({
componentName: "InteractiveDashboard",
entityId,
@@ -128,7 +123,7 @@ describe("useTrackSdkComponentMount", () => {
rerender();
rerender();
- expect(mockTrackSdkEvent).toHaveBeenCalledTimes(1);
+ expect(mockTrackSdkSimpleEvent).toHaveBeenCalledTimes(1);
});
it("deduplicates across separate hook instances with same presence key", () => {
@@ -152,7 +147,7 @@ describe("useTrackSdkComponentMount", () => {
renderOptions,
);
- expect(mockTrackSdkEvent).toHaveBeenCalledTimes(1);
+ expect(mockTrackSdkSimpleEvent).toHaveBeenCalledTimes(1);
});
it("fires separate events for different entity IDs", () => {
@@ -178,29 +173,28 @@ describe("useTrackSdkComponentMount", () => {
renderOptions,
);
- expect(mockTrackSdkEvent).toHaveBeenCalledTimes(2);
+ expect(mockTrackSdkSimpleEvent).toHaveBeenCalledTimes(2);
});
it("uses the correct component name in the emitted event", () => {
setup({ componentName: "MetabotQuestion", properties: { layout: "auto" } });
- expect(mockTrackSdkEvent).toHaveBeenCalledWith(
- expect.objectContaining({
- data: expect.objectContaining({ component: "MetabotQuestion" }),
- }),
- );
+ expect(parseLastCallDetail()).toMatchObject({
+ component: "MetabotQuestion",
+ });
});
it("fires a presence event for CreateDashboardModal", () => {
setup({ componentName: "CreateDashboardModal" });
- expect(mockTrackSdkEvent).toHaveBeenCalledWith(
+ expect(mockTrackSdkSimpleEvent).toHaveBeenCalledWith(
expect.objectContaining({
- data: expect.objectContaining({
- component: "CreateDashboardModal",
- properties: {},
- }),
+ event: "embedding_sdk_component_rendered",
}),
);
+ expect(parseLastCallDetail()).toMatchObject({
+ component: "CreateDashboardModal",
+ properties: {},
+ });
});
});
diff --git a/frontend/src/embedding-sdk-bundle/analytics/snowplow.ts b/frontend/src/embedding-sdk-bundle/analytics/snowplow.ts
index 2e9b431fe8c..8749a7e5c8a 100644
--- a/frontend/src/embedding-sdk-bundle/analytics/snowplow.ts
+++ b/frontend/src/embedding-sdk-bundle/analytics/snowplow.ts
@@ -5,6 +5,30 @@ import {
} from "@snowplow/browser-tracker";
import type { SdkStoreState } from "embedding-sdk-bundle/store/types";
+import { trackMetaplowEvent } from "metabase/utils/metaplow";
+import type { SimpleEventSchema } from "metabase-types/analytics/event";
+
+const SIMPLE_EVENT_SCHEMA_URI =
+ "iglu:com.metabase/simple_event/jsonschema/1-0-0";
+
+type ValidateEvent<
+ T extends SimpleEventSchema &
+ Record<Exclude<keyof T, keyof SimpleEventSchema>, never>,
+> = T;
+
+type EmbeddingSdkInitializedEvent = ValidateEvent<{
+ event: "embedding_sdk_initialized";
+ event_detail: string;
+}>;
+
+type EmbeddingSdkComponentRenderedEvent = ValidateEvent<{
+ event: "embedding_sdk_component_rendered";
+ event_detail: string;
+}>;
+
+type EmbeddingSdkEvent =
+ | EmbeddingSdkInitializedEvent
+ | EmbeddingSdkComponentRenderedEvent;
// The SDK runs inside the customer's app. A direct POST to the Snowplow
// collector (`sp.metabase.com`) is cross-origin and blocked by a strict
@@ -24,6 +48,7 @@ type WasJustInitialized = boolean;
let trackerInitialized = false;
let sdkAuthMethod: SdkAuthMethod;
let sdkLocaleUsed: boolean = false;
+let sdkMetaplowEnabled: boolean = false;
// Initialize the SDK's Snowplow tracker. Idempotent — safe under StrictMode double-mount.
export function initSdkTracker({
@@ -44,6 +69,9 @@ export function initSdkTracker({
sdkAuthMethod = authMethod;
sdkLocaleUsed = localeUsed;
+ const settingValues = store.getState().settings?.values;
+ sdkMetaplowEnabled = !!settingValues?.["metaplow-tracking-enabled"];
+
newTracker(SDK_TRACKER_NAME, metabaseInstanceUrl, {
appId: "metabase",
platform: "web",
@@ -107,6 +135,17 @@ function createSdkInstanceContextPlugin(store: {
// Send a self-describing event through the SDK tracker. Schema-agnostic: the caller
// supplies the Iglu schema + data, so the transport stays decoupled from the event shape.
-export function trackSdkEvent(event: SelfDescribingJson): void {
+function trackSdkEvent(event: SelfDescribingJson): void {
trackSelfDescribingEvent({ event }, [SDK_TRACKER_NAME]);
}
+
+// Use instead of trackSimpleEvent in the SDK: the main-app "sp" tracker is not
+// initialized in the customer's page, so trackSimpleEvent's Snowplow leg is a no-op.
+export function trackSdkSimpleEvent(event: EmbeddingSdkEvent): void {
+ trackSdkEvent({ schema: SIMPLE_EVENT_SCHEMA_URI, data: event });
+
+ if (sdkMetaplowEnabled) {
+ const { event: name, ...data } = event;
+ trackMetaplowEvent(name, data);
+ }
+}
diff --git a/frontend/src/embedding-sdk-bundle/analytics/snowplow.unit.spec.ts b/frontend/src/embedding-sdk-bundle/analytics/snowplow.unit.spec.ts
index ca3bb66ead9..1caf7c1e1e4 100644
--- a/frontend/src/embedding-sdk-bundle/analytics/snowplow.unit.spec.ts
+++ b/frontend/src/embedding-sdk-bundle/analytics/snowplow.unit.spec.ts
@@ -1,5 +1,3 @@
-import type { SelfDescribingJson } from "@snowplow/browser-tracker";
-
import { createMockSdkState } from "embedding-sdk-bundle/test/mocks/state";
import { createMockSettingsState } from "metabase/redux/store/mocks/settings";
import { createMockState } from "metabase/redux/store/mocks/state";
@@ -8,12 +6,17 @@ import { createMockTokenFeatures } from "metabase-types/api/mocks";
const mockNewTracker = jest.fn();
const mockTrackSelfDescribingEvent = jest.fn();
+const mockTrackMetaplowEvent = jest.fn();
jest.mock("@snowplow/browser-tracker", () => ({
newTracker: mockNewTracker,
trackSelfDescribingEvent: mockTrackSelfDescribingEvent,
}));
+jest.mock("metabase/utils/metaplow", () => ({
+ trackMetaplowEvent: mockTrackMetaplowEvent,
+}));
+
// Re-import the module under test so its module-scoped init guard resets per test.
const loadModule = () => import("./snowplow");
@@ -53,14 +56,15 @@ describe("embedding-sdk-bundle/analytics/snowplow (CSP transport)", () => {
});
expect(mockNewTracker).toHaveBeenCalledTimes(1);
+ // Only assert important config keys
expect(mockNewTracker).toHaveBeenCalledWith(
"sdk",
"https://metabase.example.com",
- // Only assert important config keys
expect.objectContaining({
postPath: "/api/analytics-proxy",
stateStorageStrategy: "none",
anonymousTracking: { withServerAnonymisation: true },
+ withCredentials: false,
}),
);
});
@@ -86,18 +90,19 @@ describe("embedding-sdk-bundle/analytics/snowplow (CSP transport)", () => {
it("wasJustInitialized: true on first call, false on subsequent calls", async () => {
const { initSdkTracker } = await loadModule();
+ const store = makeStore();
const firstResult = initSdkTracker({
metabaseInstanceUrl: "https://metabase.example.com",
authMethod: "sso",
localeUsed: false,
- store: makeStore(),
+ store,
});
const secondResult = initSdkTracker({
metabaseInstanceUrl: "https://metabase.example.com",
authMethod: "sso",
localeUsed: false,
- store: makeStore(),
+ store,
});
expect(firstResult).toBe(true);
@@ -174,19 +179,103 @@ describe("embedding-sdk-bundle/analytics/snowplow (CSP transport)", () => {
});
});
- describe("trackSdkEvent", () => {
- it("routes to the isolated sdk tracker, not the default", async () => {
- const { trackSdkEvent } = await loadModule();
- const event: SelfDescribingJson = {
- schema: "iglu:com.metabase/embedded_analytics_js/jsonschema/3-0-0",
- data: { event: "setup" },
- };
+ describe("trackSdkSimpleEvent", () => {
+ it("sends via SDK Snowplow proxy tracker with simple_event schema", async () => {
+ const { trackSdkSimpleEvent } = await loadModule();
+
+ trackSdkSimpleEvent({
+ event: "embedding_sdk_initialized",
+ event_detail: JSON.stringify({
+ global: {
+ auth_method: "sso",
+ sdk_version: "1.0.0",
+ locale_used: false,
+ },
+ }),
+ });
- trackSdkEvent(event);
+ expect(mockTrackSelfDescribingEvent).toHaveBeenCalledWith(
+ {
+ event: {
+ schema: "iglu:com.metabase/simple_event/jsonschema/1-0-0",
+ data: {
+ event: "embedding_sdk_initialized",
+ event_detail: JSON.stringify({
+ global: {
+ auth_method: "sso",
+ sdk_version: "1.0.0",
+ locale_used: false,
+ },
+ }),
+ },
+ },
+ },
+ ["sdk"],
+ );
+ });
- expect(mockTrackSelfDescribingEvent).toHaveBeenCalledWith({ event }, [
- "sdk",
- ]);
+ it("does not call Metaplow when the tracker has not been initialized", async () => {
+ const { trackSdkSimpleEvent } = await loadModule();
+
+ trackSdkSimpleEvent({
+ event: "embedding_sdk_initialized",
+ event_detail: "",
+ });
+
+ expect(mockTrackMetaplowEvent).not.toHaveBeenCalled();
+ });
+
+ it("does not call Metaplow when metaplow-tracking-enabled is false", async () => {
+ const { initSdkTracker, trackSdkSimpleEvent } = await loadModule();
+
+ initSdkTracker({
+ metabaseInstanceUrl: "https://metabase.example.com",
+ authMethod: "sso",
+ localeUsed: false,
+ store: makeStore({ "metaplow-tracking-enabled": false }),
+ });
+
+ trackSdkSimpleEvent({
+ event: "embedding_sdk_initialized",
+ event_detail: "",
+ });
+
+ expect(mockTrackMetaplowEvent).not.toHaveBeenCalled();
+ });
+
+ it("calls Metaplow when metaplow-tracking-enabled is on", async () => {
+ const { initSdkTracker, trackSdkSimpleEvent } = await loadModule();
+
+ initSdkTracker({
+ metabaseInstanceUrl: "https://metabase.example.com",
+ authMethod: "sso",
+ localeUsed: false,
+ store: makeStore({ "metaplow-tracking-enabled": true }),
+ });
+
+ trackSdkSimpleEvent({
+ event: "embedding_sdk_initialized",
+ event_detail: JSON.stringify({
+ global: {
+ auth_method: "sso",
+ sdk_version: "1.0.0",
+ locale_used: false,
+ },
+ }),
+ });
+
+ expect(mockTrackMetaplowEvent).toHaveBeenCalledWith(
+ "embedding_sdk_initialized",
+ {
+ event_detail: JSON.stringify({
+ global: {
+ auth_method: "sso",
+ sdk_version: "1.0.0",
+ locale_used: false,
+ },
+ }),
+ },
+ );
});
});
});
diff --git a/frontend/src/embedding-sdk-bundle/analytics/tracker.ts b/frontend/src/embedding-sdk-bundle/analytics/tracker.ts
index 0a7bc6c8a92..ad74291ce78 100644
--- a/frontend/src/embedding-sdk-bundle/analytics/tracker.ts
+++ b/frontend/src/embedding-sdk-bundle/analytics/tracker.ts
@@ -1,15 +1,12 @@
import { useEffect } from "react";
-import {
- EMBEDDING_SDK_SCHEMA,
- useIsTrackingEnabled,
-} from "embedding-sdk-bundle/analytics/component-events";
+import { useIsTrackingEnabled } from "embedding-sdk-bundle/analytics/component-events";
import type { SdkAuthMethod } from "embedding-sdk-bundle/analytics/snowplow";
import {
getSdkAuthMethod,
getSdkLocaleUsed,
initSdkTracker,
- trackSdkEvent,
+ trackSdkSimpleEvent,
} from "embedding-sdk-bundle/analytics/snowplow";
import { setSdkTrackerReady } from "embedding-sdk-bundle/store/reducer";
import type { SdkStore } from "embedding-sdk-bundle/store/types";
@@ -60,17 +57,15 @@ export function useInitSdkTracker(
if (wasJustInitialized) {
const sdkVersion = getSdkPackageVersion();
- trackSdkEvent({
- schema: EMBEDDING_SDK_SCHEMA,
- data: {
- component: null,
- properties: null,
+ trackSdkSimpleEvent({
+ event: "embedding_sdk_initialized",
+ event_detail: JSON.stringify({
global: {
auth_method: getSdkAuthMethod(),
sdk_version: sdkVersion,
locale_used: getSdkLocaleUsed(),
},
- },
+ }),
});
}
// isTrackingEnabled is the only dep: fire once when the opt-out gate becomes
diff --git a/frontend/src/embedding-sdk-bundle/analytics/tracker.unit.spec.tsx b/frontend/src/embedding-sdk-bundle/analytics/tracker.unit.spec.tsx
index 83c5a30fd8a..c0c32c02d51 100644
--- a/frontend/src/embedding-sdk-bundle/analytics/tracker.unit.spec.tsx
+++ b/frontend/src/embedding-sdk-bundle/analytics/tracker.unit.spec.tsx
@@ -5,7 +5,7 @@ jest.mock("embedding-sdk-bundle/analytics/component-events", () => ({
jest.mock("embedding-sdk-bundle/analytics/snowplow", () => ({
initSdkTracker: jest.fn(),
- trackSdkEvent: jest.fn(),
+ trackSdkSimpleEvent: jest.fn(),
getSdkAuthMethod: jest.fn(),
getSdkLocaleUsed: jest.fn(),
}));
@@ -19,7 +19,7 @@ import { renderHook } from "@testing-library/react";
import { useIsTrackingEnabled } from "embedding-sdk-bundle/analytics/component-events";
import {
initSdkTracker,
- trackSdkEvent,
+ trackSdkSimpleEvent,
} from "embedding-sdk-bundle/analytics/snowplow";
import { setSdkTrackerReady } from "embedding-sdk-bundle/store/reducer";
import type { MetabaseAuthConfig } from "embedding-sdk-bundle/types/auth-config";
@@ -29,7 +29,7 @@ import { deriveAuthMethod, useInitSdkTracker } from "./tracker";
const mockUseIsTrackingEnabled = jest.mocked(useIsTrackingEnabled);
const mockInitSdkTracker = jest.mocked(initSdkTracker);
-const mockTrackSdkEvent = jest.mocked(trackSdkEvent);
+const mockTrackSdkSimpleEvent = jest.mocked(trackSdkSimpleEvent);
function makeStore() {
return { dispatch: jest.fn(), getState: jest.fn() } as any;
@@ -115,14 +115,17 @@ describe("useInitSdkTracker", () => {
expect(store.dispatch).toHaveBeenCalledWith(setSdkTrackerReady(true));
});
- it("fires the init beacon only on first initialization", () => {
+ it("fires embedding_sdk_initialized beacon only on first initialization", () => {
mockUseIsTrackingEnabled.mockReturnValue(true);
mockInitSdkTracker.mockReturnValue(true);
const store = makeStore();
renderHook(() => useInitSdkTracker(SSO_AUTH_CONFIG, store, false));
- expect(mockTrackSdkEvent).toHaveBeenCalledTimes(1);
+ expect(mockTrackSdkSimpleEvent).toHaveBeenCalledTimes(1);
+ expect(mockTrackSdkSimpleEvent).toHaveBeenCalledWith(
+ expect.objectContaining({ event: "embedding_sdk_initialized" }),
+ );
});
it("does not fire the init beacon when tracker was already initialized", () => {
@@ -132,6 +135,6 @@ describe("useInitSdkTracker", () => {
renderHook(() => useInitSdkTracker(SSO_AUTH_CONFIG, store, false));
- expect(mockTrackSdkEvent).not.toHaveBeenCalled();
+ expect(mockTrackSdkSimpleEvent).not.toHaveBeenCalled();
});
});
diff --git a/frontend/src/embedding-sdk-bundle/components/public/ComponentProvider/ComponentProvider.unit.spec.tsx b/frontend/src/embedding-sdk-bundle/components/public/ComponentProvider/ComponentProvider.unit.spec.tsx
new file mode 100644
index 00000000000..61cb85a24bb
--- /dev/null
+++ b/frontend/src/embedding-sdk-bundle/components/public/ComponentProvider/ComponentProvider.unit.spec.tsx
@@ -0,0 +1,49 @@
+jest.mock("embedding-sdk-bundle/analytics/tracker", () => ({
+ useInitSdkTracker: jest.fn(),
+}));
+
+// Heavy hooks not under test — prevent real network/redux side-effects.
+jest.mock("embedding-sdk-bundle/hooks/private/use-init-data", () => ({
+ useInitDataInternal: jest.fn(),
+}));
+
+import { useInitSdkTracker } from "embedding-sdk-bundle/analytics/tracker";
+import { renderWithSDKProviders } from "embedding-sdk-bundle/test/__support__/ui";
+
+const mockUseInitSdkTracker = jest.mocked(useInitSdkTracker);
+
+describe("ComponentProvider — tracker wiring", () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ it("passes locale != null as the third argument when locale is set", () => {
+ renderWithSDKProviders(<div />, {
+ componentProviderProps: {
+ authConfig: { metabaseInstanceUrl: "https://metabase.example.com" },
+ locale: "en",
+ },
+ });
+
+ expect(mockUseInitSdkTracker).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.anything(),
+ true,
+ );
+ });
+
+ it("passes false as the third argument when locale is not set", () => {
+ renderWithSDKProviders(<div />, {
+ componentProviderProps: {
+ authConfig: { metabaseInstanceUrl: "https://metabase.example.com" },
+ locale: undefined,
+ },
+ });
+
+ expect(mockUseInitSdkTracker).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.anything(),
+ false,
+ );
+ });
+});