@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.0

package/src/sync/polling/updaters/{splitChangesUpdater.ts → definitionChangesUpdater.ts}

@@ -1,19 +1,20 @@
 import { ISegmentsCacheBase, IStorageBase } from '../../../storages/types';
-import { ISplitChangesFetcher } from '../fetchers/types';
-import { IRBSegment, ISplit, ISplitChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
+import { IDefinitionChangesFetcher } from '../fetchers/types';
+import { IRBSegment, IDefinition, IDefinitionChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE, CONFIGS_UPDATE } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
-import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_RBS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
+import { SYNC_FETCH, SYNC_UPDATE, SYNC_FETCH_FAILS, SYNC_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
 import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
 import { SPLIT_UPDATE } from '../../streaming/constants';
 import { SdkUpdateMetadata } from '../../../../types/splitio';
+import { ISplit } from '../fetchers/splitChangesFetcher';
 
 export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
-type SplitChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
+type DefinitionChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
 
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
@@ -30,8 +31,8 @@ function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
  * Collect segments from a raw FF or RBS definition.
  * Exported for testing purposes.
  */
-export function parseSegments(ruleEntity: ISplit | IRBSegment, matcherType: typeof IN_SEGMENT | typeof IN_RULE_BASED_SEGMENT = IN_SEGMENT): Set<string> {
-  const { conditions = [], excluded } = ruleEntity as IRBSegment;
+export function parseSegments(ruleEntity: IDefinition | IRBSegment, matcherType: typeof IN_SEGMENT | typeof IN_RULE_BASED_SEGMENT = IN_SEGMENT): Set<string> {
+  const { conditions, excluded } = ruleEntity as IRBSegment;
 
   const segments = new Set<string>();
   if (excluded && excluded.segments) {
@@ -42,146 +43,154 @@ export function parseSegments(ruleEntity: ISplit | IRBSegment, matcherType: type
     });
   }
 
-  for (let i = 0; i < conditions.length; i++) {
-    const matchers = conditions[i].matcherGroup.matchers;
+  if (conditions) {
+    for (let i = 0; i < conditions.length; i++) {
+      const matchers = conditions[i].matcherGroup.matchers;
 
-    matchers.forEach(matcher => {
-      if (matcher.matcherType === matcherType) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
-    });
+      matchers.forEach(matcher => {
+        if (matcher.matcherType === matcherType) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
+      });
+    }
   }
 
   return segments;
 }
 
-interface ISplitMutations<T extends ISplit | IRBSegment> {
+interface IDefinitionMutations<T extends IDefinition | IRBSegment> {
   added: T[],
-  removed: T[],
+  removed: string[],
   names: string[]
 }
 
 /**
- * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
+ * If there are defined filters and one definition doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
  * If there is `bySet` filter, `byName` and `byPrefix` filters are ignored
  *
- * @param featureFlag - feature flag to be evaluated
+ * @param definition - definition to be evaluated
  * @param filters - splitFiltersValidation bySet | byName
  */
-function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
+function matchFilters(definition: IDefinition, filters: ISplitFiltersValidation) {
   const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter } = filters.groupedFilters;
-  if (setsFilter.length > 0) return featureFlag.sets && featureFlag.sets.some((featureFlagSet: string) => setsFilter.indexOf(featureFlagSet) > -1);
+  if (setsFilter.length > 0) return definition.sets && definition.sets.some((definitionSet: string) => setsFilter.indexOf(definitionSet) > -1);
 
   const namesFilterConfigured = namesFilter.length > 0;
   const prefixFilterConfigured = prefixFilter.length > 0;
 
   if (!namesFilterConfigured && !prefixFilterConfigured) return true;
 
-  const matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
-  const matchPrefix = prefixFilterConfigured && prefixFilter.some(prefix => startsWith(featureFlag.name, prefix));
+  const matchNames = namesFilterConfigured && namesFilter.indexOf(definition.name) > -1;
+  const matchPrefix = prefixFilterConfigured && prefixFilter.some(prefix => startsWith(definition.name, prefix));
   return matchNames || matchPrefix;
 }
 
 /**
- * Given the list of splits from /splitChanges endpoint, it returns the mutations,
- * i.e., an object with added splits, removed splits and used segments.
+ * Given the list of definitions from /splitChanges or /configs endpoint, it returns the mutations,
+ * i.e., an object with added definitions, removed definitions, and used segments.
  * Exported for testing purposes.
  */
-export function computeMutation<T extends ISplit | IRBSegment>(rules: Array<T>, segments: Set<string>, filters?: ISplitFiltersValidation): ISplitMutations<T> {
-
-  return rules.reduce((accum, ruleEntity) => {
-    if (ruleEntity.status === 'ACTIVE' && (!filters || matchFilters(ruleEntity as ISplit, filters))) {
+export function computeMutation<T extends IDefinition | IRBSegment>(update: { updated: T[], removed: string[] }, segments: Set<string>, filters?: ISplitFiltersValidation): IDefinitionMutations<T> {
+  return update.updated.reduce((accum, ruleEntity) => {
+    if (!filters || matchFilters(ruleEntity as IDefinition, filters)) {
       accum.added.push(ruleEntity);
 
       parseSegments(ruleEntity).forEach((segmentName: string) => {
         segments.add(segmentName);
       });
     } else {
-      accum.removed.push(ruleEntity);
+      accum.removed.push(ruleEntity.name);
     }
     accum.names.push(ruleEntity.name);
-
     return accum;
-  }, { added: [], removed: [], names: [] } as ISplitMutations<T>);
+  }, { added: [], removed: update.removed, names: update.removed.slice() } as IDefinitionMutations<T>);
+}
+
+function convertInstantUpdateToDefinitionChanges(instantUpdate: InstantUpdate) {
+  const { payload, changeNumber } = instantUpdate;
+  return payload.status === 'ARCHIVED' ?
+    { till: changeNumber, updated: [], removed: [payload.name] } :
+    { till: changeNumber, updated: [payload], removed: [] };
 }
 
 /**
- * factory of SplitChanges updater, a task that:
- *  - fetches split changes using `splitChangesFetcher`
- *  - updates `splitsCache`
- *  - uses `splitsEventEmitter` to emit events related to split data updates
+ * Factory of DefinitionChanges updater, a task that:
+ *  - fetches definition changes using `definitionChangesFetcher`
+ *  - updates definitions storage
+ *  - uses `definitionsEventEmitter` to emit events related to definition data updates
  *
  * @param log -  Logger instance
- * @param splitChangesFetcher -  Fetcher of `/splitChanges`
- * @param splits -  Splits storage, with sync or async methods
+ * @param definitionChangesFetcher -  Fetcher of `/splitChanges` or `/configs`
+ * @param definitions -  Definitions storage, with sync or async methods
  * @param segments -  Segments storage, with sync or async methods
- * @param splitsEventEmitter -  Optional readiness manager. Not required for synchronizer or producer mode.
+ * @param definitionsEventEmitter -  Optional readiness manager. Not required for synchronizer or producer mode.
  * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
- * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
+ * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` or `/configs` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-export function splitChangesUpdaterFactory(
+export function definitionChangesUpdaterFactory(
   log: ILogger,
-  splitChangesFetcher: ISplitChangesFetcher,
+  definitionChangesFetcher: IDefinitionChangesFetcher,
   storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments' | 'save'>,
   splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady = 0,
   retriesOnFailureBeforeReady = 0,
   isClientSide?: boolean
-): SplitChangesUpdater {
+): DefinitionChangesUpdater {
   const { splits, rbSegments, segments } = storage;
 
   let startingUp = true;
 
-  /** timeout decorator for `splitChangesFetcher` promise  */
+  /** timeout decorator for `definitionChangesFetcher` promise  */
   function _promiseDecorator<T>(promise: Promise<T>) {
     if (startingUp && requestTimeoutBeforeReady) promise = timeout(requestTimeoutBeforeReady, promise);
     return promise;
   }
 
   /**
-   * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
+   * DefinitionChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch definitions or synchronize them with the storage.
    * Returned promise will not be rejected.
    *
    * @param noCache - true to revalidate data to fetch
    * @param till - query param to bypass CDN requests
    */
-  return function splitChangesUpdater(noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) {
+  return function definitionChangesUpdater(noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) {
 
     /**
-     * @param since - current changeNumber at splitsCache
+     * @param since - current changeNumber at definitionsCache
      * @param retry - current number of retry attempts
      */
-    function _splitChangesUpdater(sinces: [number, number], retry = 0): Promise<boolean> {
+    function _definitionChangesUpdater(sinces: [number, number], retry = 0): Promise<boolean> {
       const [since, rbSince] = sinces;
-      log.debug(SYNC_SPLITS_FETCH, sinces);
+      log.debug(SYNC_FETCH, [definitionChangesFetcher.type, since, rbSince]);
+
       return Promise.resolve(
         instantUpdate ?
           instantUpdate.type === SPLIT_UPDATE ?
-            // IFFU edge case: a change to a flag that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
+            // IFFU edge case: a change to definition that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
             Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, IN_RULE_BASED_SEGMENT))).then((contains) => {
               return contains ?
-                { ff: { d: [instantUpdate.payload as ISplit], t: instantUpdate.changeNumber } } :
-                splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
+                { d: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['d'] } :
+                definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
             }) :
-            { rbs: { d: [instantUpdate.payload as IRBSegment], t: instantUpdate.changeNumber } } :
-          splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
+            { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['rbs'] } :
+          definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
       )
-        .then((splitChanges: ISplitChangesResponse) => {
+        .then((definitionChanges: IDefinitionChangesResponse) => {
           const usedSegments = new Set<string>();
 
-          let updatedFlags: string[] = [];
+          let updatedDefinitions: string[] = [];
           let ffUpdate: MaybeThenable<boolean> = false;
-          if (splitChanges.ff) {
-            const { added, removed, names } = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation);
-            updatedFlags = names;
-            log.debug(SYNC_SPLITS_UPDATE, [added.length, removed.length]);
-            ffUpdate = splits.update(added, removed, splitChanges.ff.t);
+          if (definitionChanges.d) {
+            const { added, removed, names } = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation);
+            updatedDefinitions = names;
+            log.debug(SYNC_UPDATE, [definitionChangesFetcher.type, added.length, removed.length]);
+            ffUpdate = splits.update(added, removed, definitionChanges.d.till);
           }
 
           let rbsUpdate: MaybeThenable<boolean> = false;
-          if (splitChanges.rbs) {
-            const { added, removed } = computeMutation(splitChanges.rbs.d, usedSegments);
-            log.debug(SYNC_RBS_UPDATE, [added.length, removed.length]);
-            rbsUpdate = rbSegments.update(added, removed, splitChanges.rbs.t);
+          if (definitionChanges.rbs) {
+            const { added, removed } = computeMutation(definitionChanges.rbs, usedSegments);
+            log.debug(SYNC_UPDATE, ['rule-based segments', added.length, removed.length]);
+            rbsUpdate = rbSegments.update(added, removed, definitionChanges.rbs.till);
           }
 
           return Promise.all([ffUpdate, rbsUpdate,
@@ -200,8 +209,8 @@ export function splitChangesUpdaterFactory(
                   // emit SDK events
                   if (emitSplitsArrivedEvent) {
                     const metadata: SdkUpdateMetadata = {
-                      type: updatedFlags.length > 0 ? FLAGS_UPDATE : SEGMENTS_UPDATE,
-                      names: updatedFlags.length > 0 ? updatedFlags : []
+                      type: updatedDefinitions.length > 0 ? definitionChangesFetcher.type === 'configs' ? CONFIGS_UPDATE : FLAGS_UPDATE : SEGMENTS_UPDATE,
+                      names: updatedDefinitions.length > 0 ? updatedDefinitions : []
                     };
                     splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
                   }
@@ -214,17 +223,17 @@ export function splitChangesUpdaterFactory(
         .catch(error => {
           if (startingUp && retriesOnFailureBeforeReady > retry) {
             retry += 1;
-            log.warn(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
-            return _splitChangesUpdater(sinces, retry);
+            log.warn(SYNC_FETCH_RETRY, [definitionChangesFetcher.type, retry, error]);
+            return _definitionChangesUpdater(sinces, retry);
           } else {
             startingUp = false;
-            log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
+            log.warn(SYNC_FETCH_FAILS, [definitionChangesFetcher.type, error]);
           }
           return false;
         });
     }
 
     // `getChangeNumber` never rejects or throws error
-    return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_splitChangesUpdater);
+    return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_definitionChangesUpdater);
   };
 }

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -4,7 +4,7 @@ import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
-import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
+import { SYNC_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 import { IMembershipsResponse } from '../../../dtos/types';
 import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
@@ -76,7 +76,7 @@ export function mySegmentsUpdaterFactory(
     return updaterPromise.catch(error => {
       if (startingUp && retriesOnFailureBeforeReady > retry) {
         retry += 1;
-        log.warn(SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]);
+        log.warn(SYNC_FETCH_RETRY, ['memberships', retry, error]);
         return _mySegmentsUpdater(retry); // no need to forward `segmentList` and `noCache` params
       } else {
         startingUp = false;

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -3,7 +3,7 @@ import { ISegmentsCacheBase } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
 import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
-import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
+import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC } from '../../../logger/constants';
 import { timeout } from '../../../utils/promise/timeout';
 import { SdkUpdateMetadata } from '../../../../types/splitio';
 
@@ -38,7 +38,7 @@ export function segmentChangesUpdaterFactory(
   }
 
   function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean, retries?: number): Promise<boolean> {
-    log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
+    log.debug(`${LOG_PREFIX_SYNC}Processing segment ${segmentName}`);
     const sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
 
     return sincePromise.then(since => {
@@ -47,14 +47,14 @@ export function segmentChangesUpdaterFactory(
         false :
         segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then((changes) => {
           return Promise.all(changes.map(x => {
-            log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
+            log.debug(`${LOG_PREFIX_SYNC}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
             return segments.update(segmentName, x.added, x.removed, x.till);
           })).then((updates) => {
             return updates.some(update => update);
           });
         }).catch(error => {
           if (retries) {
-            log.warn(`${LOG_PREFIX_SYNC_SEGMENTS}Retrying fetch of segment ${segmentName} (attempt #${retries}). Reason: ${error}`);
+            log.warn(`${LOG_PREFIX_SYNC}Retrying fetch of segment ${segmentName} (attempt #${retries}). Reason: ${error}`);
             return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
           }
           throw error;
@@ -73,7 +73,7 @@ export function segmentChangesUpdaterFactory(
    * @param till - till target for the provided segmentName, for CDN bypass.
    */
   return function segmentChangesUpdater(fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) {
-    log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Started segments update`);
+    log.debug(`${LOG_PREFIX_SYNC}Started segments update`);
 
     // If not a segment name provided, read list of available segments names to be updated.
     let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
@@ -102,9 +102,9 @@ export function segmentChangesUpdaterFactory(
           // If the operation is forbidden, it may be due to permissions. Destroy the SDK instance.
           // @TODO although factory status is destroyed, synchronization is not stopped
           if (readiness) readiness.setDestroyed();
-          log.error(`${LOG_PREFIX_INSTANTIATION}: you passed a client-side type authorizationKey, please grab an SDK Key from the Split user interface that is of type server-side.`);
+          log.error(`${LOG_PREFIX_INSTANTIATION}: you passed a client-side type authorizationKey, please grab an SDK Key from Harness UI that is of type server-side.`);
         } else {
-          log.warn(`${LOG_PREFIX_SYNC_SEGMENTS}Error while doing fetch of segments. ${error}`);
+          log.warn(`${LOG_PREFIX_SYNC}Error while doing fetch of segments. ${error}`);
         }
 
         return false;

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

@@ -1,4 +1,4 @@
-import { IRBSegment, ISplit } from '../../../dtos/types';
+import { IRBSegment, IDefinition } from '../../../dtos/types';
 import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
 import { ILogger } from '../../../logger/types';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
@@ -7,8 +7,8 @@ import { IRBSegmentsCacheSync, ISplitsCacheSync, IStorageSync } from '../../../s
 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 { ISegmentsSyncTask, IDefinitionsSyncTask } from '../../polling/types';
+import { InstantUpdate } from '../../polling/updaters/definitionChangesUpdater';
 import { RB_SEGMENT_UPDATE } from '../constants';
 import { parseFFUpdatePayload } from '../parseUtils';
 import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
@@ -18,7 +18,7 @@ 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, storage: IStorageSync, definitionsSyncTask: IDefinitionsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData]> & { killSplit(event: ISplitKillData): void } {
 
   const ff = SplitsUpdateWorker(storage.splits);
   const rbs = SplitsUpdateWorker(storage.rbSegments);
@@ -36,7 +36,7 @@ export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSy
       if (maxChangeNumber > cache.getChangeNumber()) {
         handleNewEvent = false;
         // fetch splits revalidating data if cached
-        splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(() => {
+        definitionsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(() => {
           if (!isHandlingEvent) return; // halt if `stop` has been called
           if (handleNewEvent) {
             __handleSplitUpdateCall();
@@ -79,7 +79,7 @@ export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSy
        *
        * @param changeNumber - change number of the notification
        */
-      put({ changeNumber, pcn, type }: ISplitUpdateData, payload?: ISplit | IRBSegment) {
+      put({ changeNumber, pcn, type }: ISplitUpdateData, payload?: IDefinition | IRBSegment) {
         const currentChangeNumber = cache.getChangeNumber();
 
         if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;

package/src/sync/streaming/parseUtils.ts

@@ -1,8 +1,8 @@
 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 { Compression, IMembershipMSUpdateData } from './SSEHandler/types';
+import { IRBSegment, IDefinition } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -35,20 +35,20 @@ function decompress(data: string, compression: Compression) {
 }
 
 /**
- * Decode, decompress and parse the provided 'data' into a KeyList object
+ * Decode, decompress and parse the provided 'data' into an object of type T
  *
  * @param data - base64 encoded string
  * @param compression - 1 GZIP, 2 ZLIB
  * @param avoidPrecisionLoss - true as default, set it as false if dont need to avoid precission loss
- * @returns keyList
+ * @returns parsed object
  * @throws if data string cannot be decoded, decompressed or parsed
  */
-export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss = true): KeyList {
-  const binKeyList = decompress(data, compression);
-  let strKeyList = Uint8ArrayToString(binKeyList);
-  // replace numbers to strings, to avoid losing precision
-  if (avoidPrecisionLoss) strKeyList = strKeyList.replace(/\d+/g, '"$&"');
-  return JSON.parse(strKeyList);
+export function parseCompressedData<T>(data: string, compression: Compression, avoidPrecisionLoss = true): T {
+  const binData = decompress(data, compression);
+  let str = Uint8ArrayToString(binData);
+  // replace numbers to strings, to avoid losing precision (e.g., 64-bit IDs in KeyList)
+  if (avoidPrecisionLoss) str = str.replace(/\d+/g, '"$&"');
+  return JSON.parse(str) as T;
 }
 
 /**
@@ -82,9 +82,9 @@ 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): IDefinition | IRBSegment | undefined {
   return compression > 0 ?
-    parseKeyList(data, compression, false) :
+    parseCompressedData<IDefinition | IRBSegment>(data, compression, false) :
     JSON.parse(decodeFromBase64(data));
 }
 

package/src/sync/streaming/pushManager.ts

@@ -14,7 +14,7 @@ import { checkIfServerSide, 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 { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseCompressedData } 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, pollingManager.definitionsSyncTask, 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> = {};
@@ -243,7 +243,7 @@ export function pushManagerFactory(
       case UpdateStrategy.KeyList: {
         let keyList: KeyList, added: Set<string>, removed: Set<string>;
         try {
-          keyList = parseKeyList(parsedData.d!, parsedData.c!);
+          keyList = parseCompressedData<KeyList>(parsedData.d!, parsedData.c!);
           added = new Set(keyList.a);
           removed = new Set(keyList.r);
         } catch (e) {

package/src/sync/submitters/impressionsSubmitter.ts

@@ -3,20 +3,20 @@ import SplitIO from '../../../types/splitio';
 import { submitterFactory } from './submitter';
 import { ImpressionsPayload } from './types';
 import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { EntityType, ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.ImpressionDTO[]): ImpressionsPayload {
+export function fromImpressionsCollector(sendLabels: boolean, entityType: EntityType | undefined, data: SplitIO.ImpressionDTO[]): ImpressionsPayload {
   let groupedByFeature = groupBy(data, 'feature');
   let dto: ImpressionsPayload = [];
 
   forOwn(groupedByFeature, (value, name) => {
     dto.push({
-      f: name, // Test Name
+      f: name, // Definition type
       i: value.map(entry => { // Key Impressions
-        const keyImpression = {
+        return {
           k: entry.keyName, // Key
           t: entry.treatment, // Treatment
           m: entry.time, // Timestamp
@@ -24,10 +24,9 @@ export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.Impr
           r: sendLabels ? entry.label : undefined, // Rule
           b: entry.bucketingKey, // Bucketing Key
           pt: entry.pt, // Previous time
-          properties: entry.properties // Properties
+          properties: entry.properties, // Properties
+          et: entityType, // Definition type
         };
-
-        return keyImpression;
       })
     });
   });
@@ -43,11 +42,12 @@ export function impressionsSubmitterFactory(params: ISdkFactoryContextSync) {
   const {
     settings: { log, scheduler: { impressionsRefreshRate }, core: { labelsEnabled } },
     splitApi: { postTestImpressionsBulk },
-    storage: { impressions }
+    storage: { impressions },
+    entityType
   } = params;
 
   // retry impressions only once.
-  const syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled), 1);
+  const syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled, entityType), 1);
 
   // register impressions submitter to be executed when impressions cache is full
   impressions.setOnFullQueueCb(() => {

package/src/sync/submitters/types.ts

@@ -2,6 +2,7 @@
 import { IMetadata } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ISyncTask } from '../types';
+import { EntityType } from '../../sdkFactory/types';
 
 type ImpressionPayload = {
   /** Matching Key */
@@ -20,6 +21,8 @@ type ImpressionPayload = {
   pt?: number;
   /** Stringified JSON object with properties */
   properties?: string;
+  /** Definition type */
+  et?: EntityType,
 };
 
 export type ImpressionsPayload = {

package/src/sync/syncManagerOnline.ts

@@ -11,6 +11,8 @@ import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
 import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
+import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
+import { IDefinitionChangesFetcher } from './polling/fetchers/types';
 
 /**
  * Online SyncManager factory.
@@ -19,10 +21,12 @@ import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
+ * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
 export function syncManagerOnlineFactory(
-  pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,
+  pollingManagerFactory?: (params: ISdkFactoryContextSync, definitionChangesFetcher: IDefinitionChangesFetcher) => IPollingManager,
   pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
+  definitionChangesFetcherFactory = splitChangesFetcherFactory
 ): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**
@@ -33,7 +37,7 @@ export function syncManagerOnlineFactory(
     const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
+    const pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionChangesFetcherFactory(params));
 
     /** Push Manager */
     const pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?

package/src/trackers/eventTracker.ts

@@ -17,7 +17,6 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
 export function eventTrackerFactory(
   settings: ISettings,
   eventsCache: IEventsCacheBase,
-  whenInit: (cb: () => void) => void,
   integrationsManager?: IEventsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IEventTracker {
@@ -33,15 +32,13 @@ export function eventTrackerFactory(
     if (tracked) {
       log.info(EVENTS_TRACKER_SUCCESS, [msg]);
       if (integrationsManager) {
-        whenInit(() => {
-          // Wrap in a timeout because we don't want it to be blocking.
-          setTimeout(() => {
-            // copy of event, to avoid unexpected behavior if modified by integrations
-            const eventDataCopy = objectAssign({}, eventData);
-            if (properties) eventDataCopy.properties = objectAssign({}, properties);
-            // integrationsManager does not throw errors (they are internally handled by each integration module)
-            integrationsManager.handleEvent(eventDataCopy);
-          });
+        // Wrap in a timeout because we don't want it to be blocking.
+        setTimeout(() => {
+          // copy of event, to avoid unexpected behavior if modified by integrations
+          const eventDataCopy = objectAssign({}, eventData);
+          if (properties) eventDataCopy.properties = objectAssign({}, properties);
+          // integrationsManager does not throw errors (they are internally handled by each integration module)
+          integrationsManager.handleEvent(eventDataCopy);
         });
       }
     } else {