@copilotkit/shared 1.69.3 → 1.70.1

package/src/telemetry/telemetry-blank-license-identity.test.ts

@@ -0,0 +1,121 @@
+import { expect, test, vi } from "vitest";
+import { lambdaClient } from "./lambda-client";
+import { TelemetryClient } from "./telemetry-client";
+
+const { segmentTrackMock } = vi.hoisted(() => ({
+  segmentTrackMock: vi.fn(),
+}));
+
+vi.mock("@segment/analytics-node", () => ({
+  Analytics: class {
+    track = segmentTrackMock;
+  },
+}));
+
+const instanceCreatedEvent = {
+  actionsAmount: 0,
+  endpointTypes: [],
+  endpointsAmount: 0,
+  "cloud.api_key_provided": false,
+};
+
+/** Build the signature-agnostic legacy token shape used at this boundary. */
+function jwtWithTelemetryId(telemetryId: string): string {
+  const payload = Buffer.from(
+    JSON.stringify({ telemetry_id: telemetryId }),
+  ).toString("base64url");
+  return `header.${payload}.sig`;
+}
+
+/** Creates one isolated Shared telemetry capture with a fixed sampling decision. */
+function setupSharedCapture(randomValue: number, telemetryId: string = " \t ") {
+  const priorSampleRate = process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE;
+  delete process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE;
+  segmentTrackMock.mockReset();
+  const randomSpy = vi.spyOn(Math, "random").mockReturnValue(randomValue);
+  const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+  const client = new TelemetryClient({
+    packageName: "@copilotkit/shared",
+    packageVersion: "test",
+    telemetryDisabled: false,
+    sampleRate: 0.05,
+  });
+  client.setLicenseToken(jwtWithTelemetryId(telemetryId));
+
+  return {
+    client,
+    randomSpy,
+    teardown: () => {
+      randomSpy.mockRestore();
+      warnSpy.mockRestore();
+      segmentTrackMock.mockReset();
+      if (priorSampleRate === undefined) {
+        delete process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE;
+      } else {
+        process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE = priorSampleRate;
+      }
+    },
+  };
+}
+
+test("Shared whitespace-only legacy claim stays subject to sampling", async () => {
+  const sinkSpy = vi.spyOn(lambdaClient, "send").mockResolvedValue(undefined);
+  const { client, randomSpy, teardown } = setupSharedCapture(0.99);
+
+  try {
+    await client.capture("oss.runtime.instance_created", instanceCreatedEvent);
+
+    expect(randomSpy).toHaveBeenCalledTimes(1);
+    expect(sinkSpy).not.toHaveBeenCalled();
+    expect(segmentTrackMock).not.toHaveBeenCalled();
+  } finally {
+    sinkSpy.mockRestore();
+    teardown();
+  }
+});
+
+test("Shared sampled whitespace-only legacy claim sends no identity header", async () => {
+  const fetchSpy = vi
+    .spyOn(globalThis, "fetch")
+    .mockResolvedValue(new Response("", { status: 202 }));
+  const { client, randomSpy, teardown } = setupSharedCapture(0);
+
+  try {
+    await client.capture("oss.runtime.instance_created", instanceCreatedEvent);
+
+    expect(randomSpy).toHaveBeenCalledTimes(1);
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+    const request = fetchSpy.mock.calls[0]?.[1];
+    expect(
+      new Headers(request?.headers).get("X-CopilotKit-Telemetry-Id"),
+    ).toBeNull();
+  } finally {
+    fetchSpy.mockRestore();
+    teardown();
+  }
+});
+
+test.each(["bad\nid", "bad\u0000id", "tenant-🚀"])(
+  "Shared header-invalid legacy claim %j stays subject to sampling",
+  async (invalidTelemetryId) => {
+    const sinkSpy = vi.spyOn(lambdaClient, "send").mockResolvedValue(undefined);
+    const { client, randomSpy, teardown } = setupSharedCapture(
+      0.99,
+      invalidTelemetryId,
+    );
+
+    try {
+      await client.capture(
+        "oss.runtime.instance_created",
+        instanceCreatedEvent,
+      );
+
+      expect(randomSpy).toHaveBeenCalledTimes(1);
+      expect(sinkSpy).not.toHaveBeenCalled();
+      expect(segmentTrackMock).not.toHaveBeenCalled();
+    } finally {
+      sinkSpy.mockRestore();
+      teardown();
+    }
+  },
+);

package/src/telemetry/telemetry-client.test.ts

@@ -16,6 +16,76 @@ vi.mock("@segment/analytics-node", () => ({
   },
 }));
 
+function jwtWith(payload: {
+  telemetry_id?: string;
+  license_id?: string;
+}): string {
+  const b64 = Buffer.from(JSON.stringify(payload)).toString("base64url");
+  return `header.${b64}.sig`;
+}
+
+/** Builds a token whose payload contains an illegal base64url character. */
+function malformedJwtWithTelemetryId(telemetryId: string): string {
+  const payload = Buffer.from(JSON.stringify({ telemetry_id: telemetryId }))
+    .toString("base64url")
+    .concat("$");
+  return `header.${payload}.sig`;
+}
+
+type TelemetryIdentityMode =
+  | { label: "standalone"; telemetryId: string }
+  | { label: "legacy license"; licenseToken: string }
+  | { label: "anonymous" };
+
+/** Applies the identity path under test without conflating legacy and standalone APIs. */
+function applyTelemetryIdentity(
+  client: TelemetryClient,
+  identity: TelemetryIdentityMode,
+) {
+  if ("telemetryId" in identity) {
+    client.setTelemetryIdentity({ telemetryId: identity.telemetryId });
+    return;
+  }
+
+  if ("licenseToken" in identity) {
+    client.setLicenseToken(identity.licenseToken);
+  }
+}
+
+const telemetryIdentityModes = [
+  {
+    label: "standalone",
+    telemetryId: "standalone-telemetry-id",
+  },
+  {
+    label: "legacy license",
+    licenseToken: jwtWith({ telemetry_id: "legacy-telemetry-id" }),
+  },
+  { label: "anonymous" },
+] satisfies readonly TelemetryIdentityMode[];
+
+const telemetryOptOuts = [
+  { environmentVariable: "COPILOTKIT_TELEMETRY_DISABLED", value: "true" },
+  { environmentVariable: "DO_NOT_TRACK", value: "1" },
+] as const;
+
+const telemetryOptOutCases = telemetryOptOuts.flatMap((optOut) =>
+  telemetryIdentityModes.map((identity) => ({ identity, optOut })),
+);
+const callerSampleRate = process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE;
+
+beforeEach(() => {
+  delete process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE;
+});
+
+afterEach(() => {
+  if (callerSampleRate === undefined) {
+    delete process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE;
+  } else {
+    process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE = callerSampleRate;
+  }
+});
+
 describe("v1 TelemetryClient", () => {
   let lambdaSpy: MockInstance<typeof lambdaClient.send>;
 
@@ -26,6 +96,7 @@ describe("v1 TelemetryClient", () => {
 
   afterEach(() => {
     vi.restoreAllMocks();
+    vi.unstubAllEnvs();
   });
 
   function makeClient(
@@ -39,17 +110,83 @@ describe("v1 TelemetryClient", () => {
     });
   }
 
-  function jwtWith(payload: Record<string, unknown>): string {
-    const b64 = Buffer.from(JSON.stringify(payload)).toString("base64url");
-    return `header.${b64}.sig`;
-  }
-
   const baseInstanceEvent = {
     actionsAmount: 0,
     endpointsAmount: 0,
     endpointTypes: [],
     "cloud.api_key_provided": false,
   } as const;
+  const flattenedBaseInstanceEvent = {
+    actionsAmount: 0,
+    endpointsAmount: 0,
+    "cloud.api_key_provided": false,
+  } as const;
+
+  /**
+   * Verifies the shared event shape and sampling metadata sent to both sinks.
+   *
+   * @param expectedIdentity - Identity fields expected only on the Lambda send.
+   * @param samplingMeta - Effective sampling metadata for this capture.
+   * @param telemetryIdentified - Whether a license-derived identity bypassed sampling.
+   * @param identityValues - Raw identity values that must not leak into payloads.
+   */
+  function expectBothSinksReceivedEvent(
+    expectedIdentity: Pick<
+      Parameters<typeof lambdaClient.send>[0],
+      "licenseToken" | "telemetryId"
+    >,
+    samplingMeta: {
+      sampleRate: number;
+      sampleRateAdjustmentFactor: number;
+      sampleWeight: number;
+    },
+    telemetryIdentified: boolean,
+    identityValues: readonly string[],
+  ): void {
+    expect(lambdaSpy).toHaveBeenCalledTimes(1);
+    const lambdaEvent = lambdaSpy.mock.calls[0][0];
+    expect(lambdaEvent).toMatchObject({
+      ...expectedIdentity,
+      globalProperties: samplingMeta,
+    });
+    expect(lambdaEvent.properties).toEqual(flattenedBaseInstanceEvent);
+    expect(lambdaEvent.globalProperties).toEqual({
+      "copilotkit.package.name": "@copilotkit/shared",
+      "copilotkit.package.version": "1.0.0",
+      ...samplingMeta,
+      telemetry_emitter: "v1-shared",
+      telemetry_event_id: expect.any(String),
+      telemetry_identified: telemetryIdentified,
+      telemetry_transport: "lambda",
+    });
+
+    expect(segmentTrackMock).toHaveBeenCalledTimes(1);
+    const segmentEvent = segmentTrackMock.mock.calls[0][0];
+    expect(segmentEvent).toEqual({
+      anonymousId: expect.stringMatching(/^anon_/),
+      event: "oss.runtime.instance_created",
+      properties: {
+        ...flattenedBaseInstanceEvent,
+        "copilotkit.package.name": "@copilotkit/shared",
+        "copilotkit.package.version": "1.0.0",
+        ...samplingMeta,
+        telemetry_emitter: "v1-shared",
+        telemetry_event_id: expect.any(String),
+        telemetry_identified: telemetryIdentified,
+        telemetry_transport: "segment",
+      },
+    });
+    expect(segmentEvent).not.toHaveProperty("userId");
+
+    const transportPayload = JSON.stringify({
+      lambdaGlobalProperties: lambdaEvent.globalProperties,
+      lambdaProperties: lambdaEvent.properties,
+      segmentEvent,
+    });
+    for (const identityValue of identityValues) {
+      expect(transportPayload).not.toContain(identityValue);
+    }
+  }
 
   test("capture sends to both sinks when sampled in (anonymous, one decision gates both)", async () => {
     vi.spyOn(Math, "random").mockReturnValue(0);
@@ -76,6 +213,189 @@ describe("v1 TelemetryClient", () => {
     expect(segmentTrackMock).not.toHaveBeenCalled();
   });
 
+  test.each([
+    { label: "configured directly", priorLicenseToken: undefined },
+    {
+      label: "replacing a legacy license identity",
+      priorLicenseToken: jwtWith({ telemetry_id: "legacy-telemetry-id" }),
+    },
+  ])(
+    "standalone identity remains sample-gated when $label",
+    async ({ priorLicenseToken }) => {
+      const randomSpy = vi.spyOn(Math, "random").mockReturnValue(0.99);
+      const client = makeClient({ sampleRate: 0.05 });
+      if (priorLicenseToken !== undefined) {
+        client.setLicenseToken(priorLicenseToken);
+      }
+      client.setTelemetryIdentity({
+        telemetryId: "standalone-telemetry-id",
+      });
+
+      await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+      expect(randomSpy).toHaveBeenCalledTimes(1);
+      expect(lambdaSpy).not.toHaveBeenCalled();
+      expect(segmentTrackMock).not.toHaveBeenCalled();
+    },
+  );
+
+  test("sampled standalone identity remains a transport claim with anonymous sampling metadata", async () => {
+    const randomSpy = vi.spyOn(Math, "random").mockReturnValue(0);
+    const client = makeClient({ sampleRate: 0.05 });
+    client.setTelemetryIdentity({
+      telemetryId: "standalone-telemetry-id",
+    });
+
+    await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+    expect(randomSpy).toHaveBeenCalledTimes(1);
+    expectBothSinksReceivedEvent(
+      { telemetryId: "standalone-telemetry-id" },
+      {
+        sampleRate: 0.05,
+        sampleRateAdjustmentFactor: 0.95,
+        sampleWeight: 20,
+      },
+      false,
+      ["standalone-telemetry-id"],
+    );
+  });
+
+  test("standalone identity is stored without surrounding HTTP whitespace", async () => {
+    const randomSpy = vi.spyOn(Math, "random").mockReturnValue(0);
+    const client = makeClient({ sampleRate: 0.05 });
+    client.setTelemetryIdentity({
+      telemetryId: "\t standalone-telemetry-id \t",
+    });
+
+    await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+    expect(randomSpy).toHaveBeenCalledTimes(1);
+    expect(lambdaSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        telemetryId: "standalone-telemetry-id",
+      }),
+    );
+    expect(segmentTrackMock).toHaveBeenCalledTimes(1);
+  });
+
+  test.each(["bad\nid", "bad\u0000id", "tenant-🚀"])(
+    "header-invalid standalone identity %j stays anonymously sampled",
+    async (invalidTelemetryId) => {
+      const randomSpy = vi.spyOn(Math, "random").mockReturnValue(0);
+      const client = makeClient({ sampleRate: 0.05 });
+      client.setTelemetryIdentity({
+        telemetryId: invalidTelemetryId,
+      });
+
+      await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+      expect(randomSpy).toHaveBeenCalledTimes(1);
+      expect(lambdaSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          licenseToken: undefined,
+          telemetryId: undefined,
+        }),
+      );
+      expect(segmentTrackMock).toHaveBeenCalledTimes(1);
+    },
+  );
+
+  test("legacy license identity bypasses sampling for both sinks with the effective rate", async () => {
+    const telemetryId = "legacy-telemetry-id";
+    const licenseToken = jwtWith({ telemetry_id: telemetryId });
+    const randomSpy = vi.spyOn(Math, "random").mockReturnValue(0.99);
+    const client = makeClient({ sampleRate: 0.05 });
+    client.setTelemetryIdentity({ licenseToken });
+
+    await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+    expect(randomSpy).not.toHaveBeenCalled();
+    expectBothSinksReceivedEvent(
+      { licenseToken },
+      {
+        sampleRate: 1,
+        sampleRateAdjustmentFactor: 0,
+        sampleWeight: 1,
+      },
+      true,
+      [telemetryId, licenseToken],
+    );
+  });
+
+  test("clearing telemetry identity restores one anonymous sampling decision for both sinks", async () => {
+    const randomSpy = vi.spyOn(Math, "random").mockReturnValue(0);
+    const client = makeClient({ sampleRate: 0.05 });
+    client.setTelemetryIdentity({ telemetryId: "standalone-telemetry-id" });
+    client.setTelemetryIdentity({});
+
+    await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+    expect(randomSpy).toHaveBeenCalledTimes(1);
+    expect(lambdaSpy).toHaveBeenCalledTimes(1);
+    expect(lambdaSpy.mock.calls[0][0]).toMatchObject({
+      licenseToken: undefined,
+      telemetryId: undefined,
+      globalProperties: {
+        sampleRate: 0.05,
+        sampleRateAdjustmentFactor: 0.95,
+        sampleWeight: 20,
+      },
+    });
+    expect(segmentTrackMock).toHaveBeenCalledTimes(1);
+    expect(segmentTrackMock.mock.calls[0][0]).toMatchObject({
+      properties: expect.objectContaining({
+        sampleRate: 0.05,
+        sampleRateAdjustmentFactor: 0.95,
+        sampleWeight: 20,
+      }),
+    });
+  });
+
+  test.each(["", " \t "])(
+    "blank standalone identity %j falls through to a supplied legacy identity",
+    async (blankTelemetryId) => {
+      const randomSpy = vi.spyOn(Math, "random").mockReturnValue(0.99);
+      const licenseToken = jwtWith({ telemetry_id: "legacy-telemetry-id" });
+      const client = makeClient({ sampleRate: 0.05 });
+      client.setTelemetryIdentity({
+        telemetryId: blankTelemetryId,
+        licenseToken,
+      });
+
+      await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+      expect(randomSpy).not.toHaveBeenCalled();
+      expect(lambdaSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          licenseToken,
+          telemetryId: undefined,
+          globalProperties: expect.objectContaining({ sampleRate: 1 }),
+        }),
+      );
+    },
+  );
+
+  test.each(["", " \t "])(
+    "blank standalone identity %j without a legacy identity remains anonymously sampled",
+    async (blankTelemetryId) => {
+      const randomSpy = vi.spyOn(Math, "random").mockReturnValue(0);
+      const client = makeClient({ sampleRate: 0.05 });
+      client.setTelemetryIdentity({ telemetryId: blankTelemetryId });
+
+      await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+      expect(randomSpy).toHaveBeenCalledTimes(1);
+      expect(lambdaSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          licenseToken: undefined,
+          telemetryId: undefined,
+          globalProperties: expect.objectContaining({ sampleRate: 0.05 }),
+        }),
+      );
+    },
+  );
+
   test("identified callers bypass the sample gate (lambda + segment fire even when Math.random would fail)", async () => {
     vi.spyOn(Math, "random").mockReturnValue(0.99);
     const client = makeClient({ sampleRate: 0.05 });
@@ -107,6 +427,20 @@ describe("v1 TelemetryClient", () => {
     expect(segmentTrackMock).not.toHaveBeenCalled();
   });
 
+  test.each(telemetryOptOutCases)(
+    "$optOut.environmentVariable disables both sinks for $identity.label telemetry",
+    async ({ identity, optOut }) => {
+      vi.stubEnv(optOut.environmentVariable, optOut.value);
+      const client = makeClient();
+      applyTelemetryIdentity(client, identity);
+
+      await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+      expect(lambdaSpy).not.toHaveBeenCalled();
+      expect(segmentTrackMock).not.toHaveBeenCalled();
+    },
+  );
+
   test("setLicenseToken forwards the token in subsequent capture", async () => {
     const token = jwtWith({ telemetry_id: "abc-123" });
     const client = makeClient();
@@ -195,6 +529,19 @@ describe("v1 TelemetryClient", () => {
     expect(segmentTrackMock).not.toHaveBeenCalled();
   });
 
+  test("illegal base64url license payload cannot bypass sampleRate 0", async () => {
+    const randomSpy = vi.spyOn(Math, "random").mockReturnValue(0);
+    vi.spyOn(console, "warn").mockImplementation(() => undefined);
+    const client = makeClient({ sampleRate: 0 });
+
+    client.setLicenseToken(malformedJwtWithTelemetryId("legacy-telemetry-id"));
+    await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+    expect(randomSpy).toHaveBeenCalledTimes(1);
+    expect(lambdaSpy).not.toHaveBeenCalled();
+    expect(segmentTrackMock).not.toHaveBeenCalled();
+  });
+
   test("setLicenseToken cache is overwritable (good token replaced by bad → back to anonymous gate)", async () => {
     // Pins the cache as last-write-wins so a refactor to first-write-wins
     // (e.g. `this.telemetryId ??= parseAndWarnTelemetryId(...)`) doesn't
@@ -250,17 +597,93 @@ describe("v1 TelemetryClient", () => {
     // parseFloat('nonsense') = NaN; without the explicit guard, NaN slips
     // past the range check (all NaN comparisons are false) and produces a
     // silent always-drop. Guard the validator with Number.isNaN.
-    const original = process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE;
     process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE = "not-a-number";
-    try {
-      expect(() => makeClient()).toThrow("Sample rate must be between 0 and 1");
-    } finally {
-      if (original === undefined) {
-        delete process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE;
-      } else {
-        process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE = original;
-      }
-    }
+
+    expect(() => makeClient()).toThrow("Sample rate must be between 0 and 1");
+  });
+
+  test("both copies of one capture share a telemetry_event_id and differ only by transport", async () => {
+    // The dual-write is the whole of OSS-1019: one request, two rows, and
+    // before this nothing on either row said they were the same event.
+    // Consumers had to infer it from $lib, which is incidental.
+    vi.spyOn(Math, "random").mockReturnValue(0);
+    const client = makeClient({ sampleRate: 0.05 });
+
+    await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+    const lambdaGlobals = lambdaSpy.mock.calls[0][0].globalProperties as Record<
+      string,
+      unknown
+    >;
+    const segmentProps = segmentTrackMock.mock.calls[0][0].properties as Record<
+      string,
+      unknown
+    >;
+
+    expect(lambdaGlobals.telemetry_event_id).toEqual(expect.any(String));
+    expect(segmentProps.telemetry_event_id).toBe(
+      lambdaGlobals.telemetry_event_id,
+    );
+    expect(lambdaGlobals.telemetry_transport).toBe("lambda");
+    expect(segmentProps.telemetry_transport).toBe("segment");
+  });
+
+  test("each capture gets its own telemetry_event_id", async () => {
+    // A per-client id would collapse every event from one process into a
+    // single row under a dedupe-by-id rule.
+    vi.spyOn(Math, "random").mockReturnValue(0);
+    const client = makeClient({ sampleRate: 0.05 });
+
+    await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+    await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+    const first = (
+      lambdaSpy.mock.calls[0][0].globalProperties as Record<string, unknown>
+    ).telemetry_event_id;
+    const second = (
+      lambdaSpy.mock.calls[1][0].globalProperties as Record<string, unknown>
+    ).telemetry_event_id;
+
+    expect(first).not.toBe(second);
+  });
+
+  test("both copies are stamped as emitted by the v1 client", async () => {
+    vi.spyOn(Math, "random").mockReturnValue(0);
+    const client = makeClient({ sampleRate: 0.05 });
+
+    await client.capture("oss.runtime.instance_created", baseInstanceEvent);
+
+    expect(lambdaSpy.mock.calls[0][0].globalProperties).toMatchObject({
+      telemetry_emitter: "v1-shared",
+    });
+    expect(segmentTrackMock.mock.calls[0][0]).toMatchObject({
+      properties: expect.objectContaining({ telemetry_emitter: "v1-shared" }),
+    });
+  });
+
+  test("telemetry_identified rides on both copies and tracks the gate branch", async () => {
+    vi.spyOn(Math, "random").mockReturnValue(0);
+    const anonClient = makeClient({ sampleRate: 0.05 });
+    await anonClient.capture("oss.runtime.instance_created", baseInstanceEvent);
+    expect(lambdaSpy.mock.calls[0][0].globalProperties).toMatchObject({
+      telemetry_identified: false,
+    });
+    expect(segmentTrackMock.mock.calls[0][0]).toMatchObject({
+      properties: expect.objectContaining({ telemetry_identified: false }),
+    });
+
+    lambdaSpy.mockClear();
+    segmentTrackMock.mockReset();
+
+    const idClient = makeClient({ sampleRate: 0.05 });
+    idClient.setLicenseToken(jwtWith({ telemetry_id: "abc-123" }));
+    await idClient.capture("oss.runtime.instance_created", baseInstanceEvent);
+    expect(lambdaSpy.mock.calls[0][0].globalProperties).toMatchObject({
+      telemetry_identified: true,
+    });
+    expect(segmentTrackMock.mock.calls[0][0]).toMatchObject({
+      properties: expect.objectContaining({ telemetry_identified: true }),
+    });
   });
 });