@splitsoftware/splitio-commons 2.1.1-rc.0 → 2.1.1-rc.2

package/src/sync/streaming/SSEHandler/index.ts

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -84,7 +84,6 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
         case MEMBERSHIPS_MS_UPDATE:
         case MEMBERSHIPS_LS_UPDATE:
         case SPLIT_KILL:
-        case RB_SEGMENT_UPDATE:
           pushEmitter.emit(parsedData.type, parsedData);
           break;
 

package/src/sync/streaming/SSEHandler/types.ts

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE, RB_SEGMENT_UPDATE } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -42,7 +42,7 @@ export interface ISegmentUpdateData {
 }
 
 export interface ISplitUpdateData {
-  type: SPLIT_UPDATE | RB_SEGMENT_UPDATE,
+  type: SPLIT_UPDATE,
   changeNumber: number,
   pcn?: number,
   d?: string,

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -1,16 +1,12 @@
-import { IRBSegment, ISplit } from '../../../dtos/types';
-import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
+import { ISplit } from '../../../dtos/types';
 import { ILogger } from '../../../logger/types';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { ISplitsEventEmitter } from '../../../readiness/types';
-import { IRBSegmentsCacheSync, ISplitsCacheSync, IStorageSync } from '../../../storages/types';
+import { ISplitsCacheSync } from '../../../storages/types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
-import { InstantUpdate } from '../../polling/updaters/splitChangesUpdater';
-import { RB_SEGMENT_UPDATE } from '../constants';
-import { parseFFUpdatePayload } from '../parseUtils';
 import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 import { IUpdateWorker } from './types';
@@ -18,128 +14,102 @@ import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData]> & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
 
-  const ff = SplitsUpdateWorker(storage.splits);
-  const rbs = SplitsUpdateWorker(storage.rbSegments);
+  let maxChangeNumber = 0;
+  let handleNewEvent = false;
+  let isHandlingEvent: boolean;
+  let cdnBypass: boolean;
+  let payload: ISplit | undefined;
+  const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
 
-  function SplitsUpdateWorker(cache: ISplitsCacheSync | IRBSegmentsCacheSync) {
-    let maxChangeNumber = -1;
-    let handleNewEvent = false;
-    let isHandlingEvent: boolean;
-    let cdnBypass: boolean;
-    let instantUpdate: InstantUpdate | undefined;
-    const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+  function __handleSplitUpdateCall() {
+    isHandlingEvent = true;
+    if (maxChangeNumber > splitsCache.getChangeNumber()) {
+      handleNewEvent = false;
+      const splitUpdateNotification = payload ? { payload, changeNumber: maxChangeNumber } : undefined;
+      // fetch splits revalidating data if cached
+      splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, splitUpdateNotification).then(() => {
+        if (!isHandlingEvent) return; // halt if `stop` has been called
+        if (handleNewEvent) {
+          __handleSplitUpdateCall();
+        } else {
+          if (splitUpdateNotification) telemetryTracker.trackUpdatesFromSSE(SPLITS);
+          // fetch new registered segments for server-side API. Not retrying on error
+          if (segmentsSyncTask) segmentsSyncTask.execute(true);
 
-    function __handleSplitUpdateCall() {
-      isHandlingEvent = true;
-      if (maxChangeNumber > cache.getChangeNumber()) {
-        handleNewEvent = false;
-        // fetch splits revalidating data if cached
-        splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(() => {
-          if (!isHandlingEvent) return; // halt if `stop` has been called
-          if (handleNewEvent) {
-            __handleSplitUpdateCall();
-          } else {
-            if (instantUpdate) telemetryTracker.trackUpdatesFromSSE(SPLITS);
-            // fetch new registered segments for server-side API. Not retrying on error
-            if (segmentsSyncTask) segmentsSyncTask.execute(true);
-
-            const attempts = backoff.attempts + 1;
+          const attempts = backoff.attempts + 1;
 
-            if (ff.isSync() && rbs.isSync()) {
-              log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
-              isHandlingEvent = false;
-              return;
-            }
+          if (maxChangeNumber <= splitsCache.getChangeNumber()) {
+            log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
+            isHandlingEvent = false;
+            return;
+          }
 
-            if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-              backoff.scheduleCall();
-              return;
-            }
+          if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+            backoff.scheduleCall();
+            return;
+          }
 
-            if (cdnBypass) {
-              log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
-              isHandlingEvent = false;
-            } else {
-              backoff.reset();
-              cdnBypass = true;
-              __handleSplitUpdateCall();
-            }
+          if (cdnBypass) {
+            log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
+            isHandlingEvent = false;
+          } else {
+            backoff.reset();
+            cdnBypass = true;
+            __handleSplitUpdateCall();
           }
-        });
-      } else {
-        isHandlingEvent = false;
-      }
+        }
+      });
+    } else {
+      isHandlingEvent = false;
     }
+  }
 
-    return {
-      /**
-       * Invoked by NotificationProcessor on SPLIT_UPDATE or RB_SEGMENT_UPDATE event
-       *
-       * @param changeNumber - change number of the notification
-       */
-      put({ changeNumber, pcn, type }: ISplitUpdateData, payload?: ISplit | IRBSegment) {
-        const currentChangeNumber = cache.getChangeNumber();
+  /**
+   * Invoked by NotificationProcessor on SPLIT_UPDATE event
+   *
+   * @param changeNumber - change number of the SPLIT_UPDATE notification
+   */
+  function put({ changeNumber, pcn }: ISplitUpdateData, _payload?: ISplit) {
+    const currentChangeNumber = splitsCache.getChangeNumber();
 
-        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
+    if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
 
-        maxChangeNumber = changeNumber;
-        handleNewEvent = true;
-        cdnBypass = false;
-        instantUpdate = undefined;
+    maxChangeNumber = changeNumber;
+    handleNewEvent = true;
+    cdnBypass = false;
+    payload = undefined;
 
-        if (payload && currentChangeNumber === pcn) {
-          instantUpdate = { payload, changeNumber, type };
-        }
+    if (_payload && currentChangeNumber === pcn) {
+      payload = _payload;
+    }
 
-        if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
-        backoff.reset();
-      },
-      stop() {
-        isHandlingEvent = false;
-        backoff.reset();
-      },
-      isSync() {
-        return maxChangeNumber <= cache.getChangeNumber();
-      }
-    };
+    if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
+    backoff.reset();
   }
 
   return {
-    put(parsedData) {
-      if (parsedData.d && parsedData.c !== undefined) {
-        try {
-          const payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
-          if (payload) {
-            (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData, payload);
-            return;
-          }
-        } catch (e) {
-          log.warn(STREAMING_PARSING_SPLIT_UPDATE, [parsedData.type, e]);
-        }
-      }
-      (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData);
-    },
+    put,
     /**
      * Invoked by NotificationProcessor on SPLIT_KILL event
      *
-     * @param changeNumber - change number of the notification
+     * @param changeNumber - change number of the SPLIT_UPDATE notification
      * @param splitName - name of split to kill
      * @param defaultTreatment - default treatment value
      */
     killSplit({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
-      if (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
+      if (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
         // trigger an SDK_UPDATE if Split was killed locally
         splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
       }
       // queues the SplitChanges fetch (only if changeNumber is newer)
-      ff.put({ changeNumber } as ISplitUpdateData);
+      put({ changeNumber } as ISplitUpdateData);
     },
 
     stop() {
-      ff.stop();
-      rbs.stop();
+      isHandlingEvent = false;
+      backoff.reset();
     }
   };
 }

package/src/sync/streaming/constants.ts

@@ -30,7 +30,6 @@ export const MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export const SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export const SPLIT_KILL = 'SPLIT_KILL';
 export const SPLIT_UPDATE = 'SPLIT_UPDATE';
-export const RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper
 export const CONTROL = 'CONTROL';

package/src/sync/streaming/parseUtils.ts

@@ -2,7 +2,7 @@ import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
 import { hash } from '../../utils/murmur3/murmur3';
 import { Compression, IMembershipMSUpdateData, KeyList } from './SSEHandler/types';
-import { IRBSegment, ISplit } from '../../dtos/types';
+import { ISplit } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -82,7 +82,7 @@ export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
 /**
  * Parse feature flags notifications for instant feature flag updates
  */
-export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | IRBSegment | undefined {
+export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined {
   return compression > 0 ?
     parseKeyList(data, compression, false) :
     JSON.parse(decodeFromBase64(data));

package/src/sync/streaming/pushManager.ts

@@ -11,10 +11,10 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
@@ -56,7 +56,7 @@ export function pushManagerFactory(
   // MySegmentsUpdateWorker (client-side) are initiated in `add` method
   const segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask as ISegmentsSyncTask, storage.segments);
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-  const splitsUpdateWorker = SplitsUpdateWorker(log, storage, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
+  const splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
 
   // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
   const userKeyHashes: Record<string, string> = {};
@@ -219,8 +219,20 @@ export function pushManagerFactory(
   /** Functions related to synchronization (Queues and Workers in the spec) */
 
   pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-  pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
-  pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
+  pushEmitter.on(SPLIT_UPDATE, (parsedData) => {
+    if (parsedData.d && parsedData.c !== undefined) {
+      try {
+        const payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
+        if (payload) {
+          splitsUpdateWorker.put(parsedData, payload);
+          return;
+        }
+      } catch (e) {
+        log.warn(STREAMING_PARSING_SPLIT_UPDATE, [e]);
+      }
+    }
+    splitsUpdateWorker.put(parsedData);
+  });
 
   function handleMySegmentsUpdate(parsedData: IMembershipMSUpdateData | IMembershipLSUpdateData) {
     switch (parsedData.u) {

package/src/sync/streaming/types.ts

@@ -16,19 +16,18 @@ export type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
-export type RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
   T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :
   T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
-  T extends SPLIT_UPDATE | RB_SEGMENT_UPDATE ? ISplitUpdateData :
+  T extends SPLIT_UPDATE ? ISplitUpdateData :
   T extends SPLIT_KILL ? ISplitKillData : INotificationData;
 
 /**

package/src/sync/submitters/impressionsSubmitter.ts

@@ -25,8 +25,9 @@ export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.Impr
           m: entry.time, // Timestamp
           c: entry.changeNumber, // ChangeNumber
           r: sendLabels ? entry.label : undefined, // Rule
-          b: entry.bucketingKey ? entry.bucketingKey : undefined, // Bucketing Key
-          pt: entry.pt ? entry.pt : undefined // Previous time
+          b: entry.bucketingKey, // Bucketing Key
+          pt: entry.pt, // Previous time
+          properties: entry.properties // Properties
         };
 
         return keyImpression;

package/src/sync/submitters/types.ts

@@ -3,26 +3,30 @@ import { IMetadata } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ISyncTask } from '../types';
 
+type ImpressionPayload = {
+  /** Matching Key */
+  k: string;
+  /** Bucketing Key */
+  b?: string;
+  /** Treatment */
+  t: string;
+  /** Timestamp */
+  m: number;
+  /** Change number */
+  c: number;
+  /** Rule label */
+  r?: string;
+  /** Previous time */
+  pt?: number;
+  /** Stringified JSON object with properties */
+  properties?: string;
+};
+
 export type ImpressionsPayload = {
   /** Split name */
   f: string,
   /** Key Impressions */
-  i: {
-    /** User Key */
-    k: string;
-    /** Treatment */
-    t: string;
-    /** Timestamp */
-    m: number;
-    /** ChangeNumber */
-    c: number;
-    /** Rule label */
-    r?: string;
-    /** Bucketing Key */
-    b?: string;
-    /** Previous time */
-    pt?: number;
-  }[]
+  i: ImpressionPayload[]
 }[]
 
 export type ImpressionCountsPayload = {
@@ -60,23 +64,9 @@ export type StoredImpressionWithMetadata = {
   /** Metadata */
   m: IMetadata,
   /** Stored impression */
-  i: {
-    /** keyName */
-    k: string,
-    /** bucketingKey */
-    b?: string,
-    /** Split name */
-    f: string,
-    /** treatment */
-    t: string,
-    /** label */
-    r: string,
-    /** changeNumber */
-    c: number,
-    /** time */
-    m: number
-    /** previous time */
-    pt?: number
+  i: ImpressionPayload & {
+    /** Feature flag name */
+    f: string
   }
 }
 

package/src/sync/syncManagerOnline.ts

@@ -9,6 +9,7 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
 import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
+import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 
 /**
  * Online SyncManager factory.
@@ -28,7 +29,7 @@ export function syncManagerOnlineFactory(
    */
   return function (params: ISdkFactoryContextSync): ISyncManagerCS {
 
-    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } },  telemetryTracker } = params;
+    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;
 
     /** Polling Manager */
     const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
@@ -87,6 +88,11 @@ export function syncManagerOnlineFactory(
       start() {
         running = true;
 
+        if (startFirstTime) {
+          const isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
+          if (isCacheLoaded) Promise.resolve().then(() => { readiness.splits.emit(SDK_SPLITS_CACHE_LOADED); });
+        }
+
         // start syncing splits and segments
         if (pollingManager) {
 
@@ -96,7 +102,6 @@ export function syncManagerOnlineFactory(
               // Doesn't call `syncAll` when the syncManager is resuming
               if (startFirstTime) {
                 pollingManager.syncAll();
-                startFirstTime = false;
               }
               pushManager.start();
             } else {
@@ -105,13 +110,14 @@ export function syncManagerOnlineFactory(
           } else {
             if (startFirstTime) {
               pollingManager.syncAll();
-              startFirstTime = false;
             }
           }
         }
 
         // start periodic data recording (events, impressions, telemetry).
         submitterManager.start(!isConsentGranted(settings));
+
+        startFirstTime = false;
       },
 
       /**
@@ -149,14 +155,14 @@ export function syncManagerOnlineFactory(
             if (pushManager) {
               if (pollingManager.isRunning()) {
                 // if doing polling, we must start the periodic fetch of data
-                if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) mySegmentsSyncTask.start();
+                if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
               } else {
                 // if not polling, we must execute the sync task for the initial fetch
                 // of segments since `syncAll` was already executed when starting the main client
                 mySegmentsSyncTask.execute();
               }
             } else {
-              if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) mySegmentsSyncTask.start();
+              if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
             }
           } else {
             if (!readinessManager.isReady()) mySegmentsSyncTask.execute();

package/src/trackers/strategy/strategyDebug.ts

@@ -14,6 +14,8 @@ export function strategyDebugFactory(
 
   return {
     process(impression: SplitIO.ImpressionDTO) {
+      if (impression.properties) return true;
+
       impression.pt = impressionsObserver.testAndSet(impression);
       return true;
     }

package/src/trackers/strategy/strategyOptimized.ts

@@ -18,6 +18,9 @@ export function strategyOptimizedFactory(
 
   return {
     process(impression: SplitIO.ImpressionDTO) {
+      // DEBUG mode without previous time, for impressions with properties
+      if (impression.properties) return true;
+
       impression.pt = impressionsObserver.testAndSet(impression);
 
       const now = Date.now();

package/src/utils/constants/index.ts

@@ -104,9 +104,8 @@ export const DISABLED = 0;
 export const ENABLED = 1;
 export const PAUSED = 2;
 
-export const FLAG_SPEC_VERSION = '1.3';
+export const FLAG_SPEC_VERSION = '1.2';
 
 // Matcher types
 export const IN_SEGMENT = 'IN_SEGMENT';
 export const IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';
-export const IN_RULE_BASED_SEGMENT = 'IN_RULE_BASED_SEGMENT';

package/src/utils/inputValidation/eventProperties.ts

@@ -66,3 +66,13 @@ export function validateEventProperties(log: ILogger, maybeProperties: any, meth
 
   return output;
 }
+
+export function validateEvaluationOptions(log: ILogger, maybeOptions: any, method: string): SplitIO.EvaluationOptions | undefined {
+  if (isObject(maybeOptions)) {
+    const properties = validateEventProperties(log, maybeOptions.properties, method).properties;
+    return properties && Object.keys(properties).length > 0 ? { properties } : undefined;
+  } else if (maybeOptions) {
+    log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'evaluation options']);
+  }
+  return undefined;
+}

package/src/utils/inputValidation/index.ts

@@ -11,3 +11,4 @@ export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
 export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validatePreloadedData } from './preloadedData';
+export { validateEvaluationOptions } from './eventProperties';

package/src/utils/lang/index.ts

@@ -111,7 +111,7 @@ export function groupBy<T extends Record<string, any>>(source: T[], prop: string
 /**
  * Checks if a given value is a boolean.
  */
-export function isBoolean(val: any): val is boolean {
+export function isBoolean(val: any): boolean {
   return val === true || val === false;
 }
 
@@ -120,7 +120,7 @@ export function isBoolean(val: any): val is boolean {
  * Unlike `Number.isFinite`, it also tests Number object instances.
  * Unlike global `isFinite`, it returns false if the value is not a number or Number object instance.
  */
-export function isFiniteNumber(val: any): boolean {
+export function isFiniteNumber(val: any): val is number {
   if (val instanceof Number) val = val.valueOf();
   return typeof val === 'number' ?
     Number.isFinite ? Number.isFinite(val) : isFinite(val) :

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -8,7 +8,7 @@ import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
 
 export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync {
   const result = InMemoryStorageCSFactory(params);
-  result.splits.checkCache = () => true; // to emit SDK_READY_FROM_CACHE
+  result.validateCache = () => true; // to emit SDK_READY_FROM_CACHE
   return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;