Add ready metadata and polling

Author: ZamoraEmmanuel

src/readiness/__tests__/readinessManager.spec.ts

@@ -3,7 +3,7 @@ import { EventEmitter } from '../../utils/MinEvents';
 import { IReadinessManager } from '../types';
 import { SDK_READY, SDK_UPDATE, SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_READY_FROM_CACHE, SDK_SPLITS_CACHE_LOADED, SDK_READY_TIMED_OUT } from '../constants';
 import { ISettings } from '../../types';
-import { SdkUpdateMetadata, SdkUpdateMetadataKeys } from '../../../types/splitio';
+import { SdkUpdateMetadata, SdkUpdateMetadataKeys, SdkReadyMetadata } from '../../../types/splitio';
 
 const settings = {
   startup: {
@@ -362,3 +362,81 @@ test('READINESS MANAGER / SDK_UPDATE should forward metadata from segments', ()
 
   expect(receivedMetadata).toEqual(metadata);
 });
+
+test('READINESS MANAGER / SDK_READY_FROM_CACHE should emit with metadata when cache is loaded', () => {
+  const readinessManager = readinessManagerFactory(EventEmitter, settings);
+
+  let receivedMetadata: SdkReadyMetadata | undefined;
+  readinessManager.gate.on(SDK_READY_FROM_CACHE, (meta: SdkReadyMetadata) => {
+    receivedMetadata = meta;
+  });
+
+  // Emit cache loaded event
+  readinessManager.splits.emit(SDK_SPLITS_CACHE_LOADED);
+
+  expect(receivedMetadata).toBeDefined();
+  expect(receivedMetadata!.initialCacheLoad).toBe(true);
+  expect(receivedMetadata!.lastUpdateTimestamp).toBeGreaterThan(0);
+  // Allow small timing difference (up to 10ms)
+  expect(receivedMetadata!.lastUpdateTimestamp).toBeLessThanOrEqual(Date.now() + 10);
+});
+
+test('READINESS MANAGER / SDK_READY_FROM_CACHE should emit with metadata when SDK becomes ready without cache', () => {
+  const readinessManager = readinessManagerFactory(EventEmitter, settings);
+
+  let receivedMetadata: SdkReadyMetadata | undefined;
+  readinessManager.gate.on(SDK_READY_FROM_CACHE, (meta: SdkReadyMetadata) => {
+    receivedMetadata = meta;
+  });
+
+  // Make SDK ready without cache first
+  readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
+  readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
+
+  expect(receivedMetadata).toBeDefined();
+  expect(receivedMetadata!.initialCacheLoad).toBe(false);
+  expect(receivedMetadata!.lastUpdateTimestamp).toBeGreaterThan(0);
+  // Allow small timing difference (up to 10ms)
+  expect(receivedMetadata!.lastUpdateTimestamp).toBeLessThanOrEqual(Date.now() + 10);
+});
+
+test('READINESS MANAGER / SDK_READY should emit with metadata when ready from cache', () => {
+  const readinessManager = readinessManagerFactory(EventEmitter, settings);
+
+  // First emit cache loaded
+  readinessManager.splits.emit(SDK_SPLITS_CACHE_LOADED);
+
+  let receivedMetadata: SdkReadyMetadata | undefined;
+  readinessManager.gate.on(SDK_READY, (meta: SdkReadyMetadata) => {
+    receivedMetadata = meta;
+  });
+
+  // Make SDK ready
+  readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
+  readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
+
+  expect(receivedMetadata).toBeDefined();
+  expect(receivedMetadata!.initialCacheLoad).toBe(true); // Was ready from cache first
+  expect(receivedMetadata!.lastUpdateTimestamp).toBeGreaterThan(0);
+  // Allow small timing difference (up to 10ms)
+  expect(receivedMetadata!.lastUpdateTimestamp).toBeLessThanOrEqual(Date.now() + 10);
+});
+
+test('READINESS MANAGER / SDK_READY should emit with metadata when ready without cache', () => {
+  const readinessManager = readinessManagerFactory(EventEmitter, settings);
+
+  let receivedMetadata: SdkReadyMetadata | undefined;
+  readinessManager.gate.on(SDK_READY, (meta: SdkReadyMetadata) => {
+    receivedMetadata = meta;
+  });
+
+  // Make SDK ready without cache
+  readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
+  readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
+
+  expect(receivedMetadata).toBeDefined();
+  expect(receivedMetadata!.initialCacheLoad).toBe(false); // Was not ready from cache
+  expect(receivedMetadata!.lastUpdateTimestamp).toBeGreaterThan(0);
+  // Allow small timing difference (up to 10ms)
+  expect(receivedMetadata!.lastUpdateTimestamp).toBeLessThanOrEqual(Date.now() + 10);
+});

src/readiness/readinessManager.ts

@@ -90,7 +90,11 @@ export function readinessManagerFactory(
     if (!isReady && !isDestroyed) {
       try {
         syncLastUpdate();
-        gate.emit(SDK_READY_FROM_CACHE, isReady);
+        const metadata: SplitIO.SdkReadyMetadata = {
+          initialCacheLoad: true,
+          lastUpdateTimestamp: lastUpdate
+        };
+        gate.emit(SDK_READY_FROM_CACHE, metadata);
       } catch (e) {
         // throws user callback exceptions in next tick
         setTimeout(() => { throw e; }, 0);
@@ -114,11 +118,20 @@ export function readinessManagerFactory(
         isReady = true;
         try {
           syncLastUpdate();
+          const wasReadyFromCache = isReadyFromCache;
           if (!isReadyFromCache) {
             isReadyFromCache = true;
-            gate.emit(SDK_READY_FROM_CACHE, isReady);
+            const metadataFromCache: SplitIO.SdkReadyMetadata = {
+              initialCacheLoad: false,
+              lastUpdateTimestamp: lastUpdate
+            };
+            gate.emit(SDK_READY_FROM_CACHE, metadataFromCache);
           }
-          gate.emit(SDK_READY);
+          const metadataReady: SplitIO.SdkReadyMetadata = {
+            initialCacheLoad: wasReadyFromCache,
+            lastUpdateTimestamp: lastUpdate
+          };
+          gate.emit(SDK_READY, metadataReady);
         } catch (e) {
           // throws user callback exceptions in next tick
           setTimeout(() => { throw e; }, 0);

src/readiness/types.ts

@@ -12,6 +12,18 @@ export type IReadinessEvent = SDK_READY_TIMED_OUT | SDK_READY | SDK_READY_FROM_C
 
 export interface IReadinessEventEmitter extends SplitIO.IEventEmitter {
   emit(event: IReadinessEvent, ...args: any[]): boolean
+  on(event: SDK_READY, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  on(event: SDK_READY_FROM_CACHE, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  on(event: SDK_UPDATE, listener: (metadata: SplitIO.SdkUpdateMetadata) => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+  once(event: SDK_READY, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  once(event: SDK_READY_FROM_CACHE, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  once(event: SDK_UPDATE, listener: (metadata: SplitIO.SdkUpdateMetadata) => void): this;
+  once(event: string | symbol, listener: (...args: any[]) => void): this;
+  addListener(event: SDK_READY, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  addListener(event: SDK_READY_FROM_CACHE, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  addListener(event: SDK_UPDATE, listener: (metadata: SplitIO.SdkUpdateMetadata) => void): this;
+  addListener(event: string | symbol, listener: (...args: any[]) => void): this;
 }
 /** Splits data emitter */
 

src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -9,6 +9,7 @@ import { ISettings } from '../../../types';
 import { CONTROL } from '../../../utils/constants';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
+import { SdkUpdateMetadataKeys } from '../../../../types/splitio';
 
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
@@ -55,15 +56,15 @@ export function fromObjectUpdaterFactory(
         splitsCache.clear(), // required to sync removed splits from mock
         splitsCache.update(splits, [], Date.now())
       ]).then(() => {
-        readiness.splits.emit(SDK_SPLITS_ARRIVED);
+        readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: SdkUpdateMetadataKeys.FLAGS_UPDATE, names: [] });
 
         if (startingUp) {
           startingUp = false;
           Promise.resolve(storage.validateCache ? storage.validateCache() : false).then((isCacheLoaded) => {
             // Emits SDK_READY_FROM_CACHE
             if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
             // Emits SDK_READY
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+            readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
           });
         }
         return true;

src/sync/polling/pollingManagerCS.ts

@@ -9,6 +9,7 @@ import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/consta
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
+import { SdkUpdateMetadata } from '../../../types/splitio';
 
 /**
  * Expose start / stop mechanism for polling data from services.
@@ -59,8 +60,8 @@ export function pollingManagerCSFactory(
     const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
 
     // smart ready
-    function smartReady() {
-      if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+    function smartReady(metadata: SdkUpdateMetadata) {
+      if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
     }
     if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
     else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);

src/sync/polling/updaters/__tests__/mySegmentsUpdater.spec.ts

@@ -0,0 +1,108 @@
+import { readinessManagerFactory } from '../../../../readiness/readinessManager';
+import { MySegmentsCacheInMemory } from '../../../../storages/inMemory/MySegmentsCacheInMemory';
+import { mySegmentsUpdaterFactory } from '../mySegmentsUpdater';
+import { fullSettings } from '../../../../utils/settingsValidation/__tests__/settings.mocks';
+import { EventEmitter } from '../../../../utils/MinEvents';
+import { loggerMock } from '../../../../logger/__tests__/sdkLogger.mock';
+import { IMySegmentsFetcher } from '../../fetchers/types';
+import { IMembershipsResponse } from '../../../../dtos/types';
+import { SDK_SEGMENTS_ARRIVED } from '../../../../readiness/constants';
+import { SdkUpdateMetadataKeys } from '../../../../../types/splitio';
+import { MySegmentsData } from '../../types';
+import { MEMBERSHIPS_MS_UPDATE } from '../../../streaming/constants';
+import { IStorageSync } from '../../../../storages/types';
+import { SplitsCacheInMemory } from '../../../../storages/inMemory/SplitsCacheInMemory';
+import { RBSegmentsCacheInMemory } from '../../../../storages/inMemory/RBSegmentsCacheInMemory';
+
+describe('mySegmentsUpdater', () => {
+  const segments = new MySegmentsCacheInMemory();
+  const largeSegments = new MySegmentsCacheInMemory();
+  const splits = new SplitsCacheInMemory();
+  const rbSegments = new RBSegmentsCacheInMemory();
+  const storage: IStorageSync = {
+    segments,
+    largeSegments,
+    splits,
+    rbSegments,
+    impressions: {} as any,
+    events: {} as any,
+    impressionCounts: {} as any,
+    telemetry: undefined,
+    uniqueKeys: {} as any,
+    save: () => {},
+    destroy: () => {}
+  };
+  const readinessManager = readinessManagerFactory(EventEmitter, fullSettings);
+  const segmentsEmitSpy = jest.spyOn(readinessManager.segments, 'emit');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    storage.segments.clear();
+    readinessManager.segments.segmentsArrived = false;
+  });
+
+  test('test with mySegments update - should emit SEGMENTS_UPDATE metadata', async () => {
+    const mockMySegmentsFetcher: IMySegmentsFetcher = jest.fn().mockResolvedValue({
+      ms: { 'segment1': true, 'segment2': true },
+      ls: {}
+    } as IMembershipsResponse);
+
+    const mySegmentsUpdater = mySegmentsUpdaterFactory(
+      loggerMock,
+      mockMySegmentsFetcher,
+      storage,
+      readinessManager.segments,
+      1000,
+      1,
+      'test-key'
+    );
+
+    await mySegmentsUpdater();
+
+    expect(segmentsEmitSpy).toBeCalledWith(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+  });
+
+  test('test with mySegments data payload - should emit SEGMENTS_UPDATE metadata', async () => {
+    const segmentsData: MySegmentsData = {
+      type: MEMBERSHIPS_MS_UPDATE,
+      cn: 123,
+      added: ['segment1', 'segment2'],
+      removed: []
+    };
+
+    const mySegmentsUpdater = mySegmentsUpdaterFactory(
+      loggerMock,
+      jest.fn().mockResolvedValue({ ms: {}, ls: {} } as IMembershipsResponse),
+      storage,
+      readinessManager.segments,
+      1000,
+      1,
+      'test-key'
+    );
+
+    await mySegmentsUpdater(segmentsData);
+
+    expect(segmentsEmitSpy).toBeCalledWith(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+  });
+
+  test('test with empty mySegments - should still emit SEGMENTS_UPDATE metadata', async () => {
+    const mockMySegmentsFetcher: IMySegmentsFetcher = jest.fn().mockResolvedValue({
+      ms: {},
+      ls: {}
+    } as IMembershipsResponse);
+
+    const mySegmentsUpdater = mySegmentsUpdaterFactory(
+      loggerMock,
+      mockMySegmentsFetcher,
+      storage,
+      readinessManager.segments,
+      1000,
+      1,
+      'test-key'
+    );
+
+    await mySegmentsUpdater();
+
+    expect(segmentsEmitSpy).toBeCalledWith(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+  });
+});

src/sync/polling/updaters/__tests__/segmentChangesUpdater.spec.ts

@@ -50,4 +50,86 @@ describe('segmentChangesUpdater', () => {
     expect(updateSegments).toHaveBeenCalledWith(segmentName, segmentChange.added, segmentChange.removed, segmentChange.till);
     expect(segmentsEmitSpy).toBeCalledWith(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
   });
+
+  test('test with multiple segments update - should emit SEGMENTS_UPDATE metadata once', async () => {
+    const segment1 = 'segment1';
+    const segment2 = 'segment2';
+    const segment3 = 'segment3';
+
+    const segmentChange1: ISegmentChangesResponse = {
+      name: segment1,
+      added: ['key1'],
+      removed: [],
+      since: -1,
+      till: 100
+    };
+
+    const segmentChange2: ISegmentChangesResponse = {
+      name: segment2,
+      added: ['key2'],
+      removed: [],
+      since: -1,
+      till: 101
+    };
+
+    const segmentChange3: ISegmentChangesResponse = {
+      name: segment3,
+      added: ['key3'],
+      removed: [],
+      since: -1,
+      till: 102
+    };
+
+    const mockSegmentChangesFetcher: ISegmentChangesFetcher = jest.fn().mockResolvedValue([
+      segmentChange1,
+      segmentChange2,
+      segmentChange3
+    ]);
+
+    const segmentChangesUpdater = segmentChangesUpdaterFactory(
+      loggerMock,
+      mockSegmentChangesFetcher,
+      segments,
+      readinessManager,
+      1000,
+      1
+    );
+
+    segments.registerSegments([segment1, segment2, segment3]);
+
+    // Update all segments at once
+    await segmentChangesUpdater(undefined);
+
+    // Should emit once when all segments are updated
+    expect(segmentsEmitSpy).toHaveBeenCalledTimes(1);
+    expect(segmentsEmitSpy).toBeCalledWith(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+  });
+
+  test('test with empty segments - should still emit SEGMENTS_UPDATE metadata', async () => {
+    const segmentName = 'empty-segment';
+    const segmentChange: ISegmentChangesResponse = {
+      name: segmentName,
+      added: [],
+      removed: [],
+      since: -1,
+      till: 123
+    };
+
+    const mockSegmentChangesFetcher: ISegmentChangesFetcher = jest.fn().mockResolvedValue([segmentChange]);
+
+    const segmentChangesUpdater = segmentChangesUpdaterFactory(
+      loggerMock,
+      mockSegmentChangesFetcher,
+      segments,
+      readinessManager,
+      1000,
+      1
+    );
+
+    segments.registerSegments([segmentName]);
+
+    await segmentChangesUpdater(undefined, segmentName);
+
+    expect(segmentsEmitSpy).toBeCalledWith(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+  });
 });