fix(experiment-tag): address Bugbot relay flush and sync issues

Keep pending writes until RPC confirms, include event id in merge dedup key,
use writeEvent retry queue on FIFO trim, and retain relay client on sync failure.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: tyiuhc

packages/experiment-tag/src/behavioral-targeting/behavioral-targeting-manager.ts

@@ -89,7 +89,6 @@ export class BehavioralTargetingManager {
     }
     const synced = await this.syncFromRelay();
     if (!synced) {
-      this.setRelayClient(null);
       return false;
     }
     return behaviorsBefore !== this.serializeMatchedBehaviors();

packages/experiment-tag/src/behavioral-targeting/event-storage.ts

@@ -3,13 +3,15 @@ import { RelayEventStorage } from './relay-protocol';
 import { SessionManager } from './session-manager';
 
 /**
- * Dedup key for cross-subdomain merge (matches relay.js MIGRATE_EVENTS).
+ * Dedup key for cross-subdomain merge (matches relay.js MIGRATE_EVENTS for
+ * migration; includes id so same-millisecond events do not collapse on merge).
  */
 export function eventDedupKey(event: {
   event_type: string;
   timestamp: number;
+  id: number;
 }): string {
-  return `${event.event_type}:${event.timestamp}`;
+  return `${event.event_type}:${event.timestamp}:${event.id}`;
 }
 
 /**
@@ -315,14 +317,9 @@ export class EventStorageManager {
     if (!relay?.relayAvailable) {
       return;
     }
-    void relay
-      .migrateEvents(window.location.origin, {
-        events: [...this.memoryCache.events],
-        nextId: this.memoryCache.nextId,
-      })
-      .catch(() => {
-        // fire-and-forget
-      });
+    for (const event of this.memoryCache.events) {
+      relay.writeEvent(event);
+    }
   }
 
   private scheduleDebouncedWrite(): void {

packages/experiment-tag/src/behavioral-targeting/relay-client.ts

@@ -234,37 +234,38 @@ export class RelayClient {
 
     // Queue until async write confirms — flush() can resend in-flight events on unload.
     this.pendingWrites.push(event);
+    this.sendPendingWrite(event);
+  }
+
+  private removeConfirmedWrite(event: RelayEventRecord): void {
+    const idx = this.pendingWrites.indexOf(event);
+    if (idx !== -1) {
+      this.pendingWrites.splice(idx, 1);
+    }
+  }
 
+  private sendPendingWrite(event: RelayEventRecord): void {
     if (!this.available || !this.iframeWindow) {
       return;
     }
 
     void this.sendRequest(this.createRelayRequest('WRITE_EVENT', { event }))
       .then((response) => {
-        if (!response.ok) {
-          return;
-        }
-        const idx = this.pendingWrites.indexOf(event);
-        if (idx !== -1) {
-          this.pendingWrites.splice(idx, 1);
+        if (response.ok) {
+          this.removeConfirmedWrite(event);
         }
       })
       .catch(() => {
-        // Keep in pendingWrites for flush()
+        // Keep in pendingWrites for a later flush()
       });
   }
 
   flush(): void {
     if (!this.available || !this.iframeWindow) {
       return;
     }
-    const writes = [...this.pendingWrites];
-    this.pendingWrites = [];
-    for (const event of writes) {
-      this.iframeWindow.postMessage(
-        this.createRelayRequest('WRITE_EVENT', { event }),
-        this.relayOrigin,
-      );
+    for (const event of [...this.pendingWrites]) {
+      this.sendPendingWrite(event);
     }
   }
 

packages/experiment-tag/test/behavioral-targeting/event-storage.test.ts

@@ -417,10 +417,10 @@ describe('EventStorageManager', () => {
   });
 
   describe('eventDedupKey', () => {
-    test('uses event_type and timestamp', () => {
-      expect(eventDedupKey({ event_type: 'click', timestamp: 1000 })).toBe(
-        'click:1000',
-      );
+    test('uses event_type, timestamp, and id', () => {
+      expect(
+        eventDedupKey({ event_type: 'click', timestamp: 1000, id: 1 }),
+      ).toBe('click:1000:1');
     });
   });
 
@@ -461,24 +461,22 @@ describe('EventStorageManager', () => {
       expect(relay.flush).toHaveBeenCalled();
     });
 
-    test('re-migrates relay cache when FIFO trim evicts local events', () => {
+    test('re-writes relay cache via writeEvent when FIFO trim evicts local events', () => {
       for (let i = 0; i < 500; i++) {
         eventStorage.addEvent('test', { index: i });
       }
 
       const relay = createMockRelay();
       eventStorage.setRelayClient(relay as unknown as RelayClient);
+      relay.writeEvent.mockClear();
       eventStorage.addEvent('test', { index: 500 });
 
-      expect(relay.migrateEvents).toHaveBeenCalledWith(
-        window.location.origin,
-        expect.objectContaining({
-          events: expect.arrayContaining([
-            expect.objectContaining({ properties: { index: 500 } }),
-          ]),
-        }),
-      );
-      expect(relay.writeEvent).not.toHaveBeenCalled();
+      expect(relay.writeEvent).toHaveBeenCalled();
+      expect(
+        relay.writeEvent.mock.calls.some(
+          ([event]) => event.properties?.index === 500,
+        ),
+      ).toBe(true);
     });
   });
 
@@ -509,6 +507,20 @@ describe('EventStorageManager', () => {
       expect(events[0].properties).toEqual({ source: 'relay' });
       expect(events[1].event_type).toBe('view');
     });
+
+    test('keeps same-millisecond events with different ids', () => {
+      eventStorage.addEvent('click', {}, 1000);
+      eventStorage.addEvent('click', {}, 1000);
+
+      expect(eventStorage.getAllEvents()).toHaveLength(2);
+
+      eventStorage.mergeFromRelay({
+        events: [],
+        nextId: 1,
+      });
+
+      expect(eventStorage.getAllEvents()).toHaveLength(2);
+    });
   });
 
   describe('syncFromRelay', () => {