@splitsoftware/splitio-commons 1.16.0 → 1.16.1-rc.1

package/esm/sync/streaming/pushManager.js

@@ -8,13 +8,19 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, 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 { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType, MY_LARGE_SEGMENTS_UPDATE } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
 import { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { _Set } from '../../utils/lang/sets';
+import { hash } from '../../utils/murmur3/murmur3';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
-import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
+import { TOKEN_REFRESH, AUTH_REJECTION, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
+export function getDelay(parsedData, matchingKey) {
+    var interval = parsedData.i || 60000;
+    var seed = parsedData.s || 0;
+    return hash(matchingKey, seed) % interval;
+}
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
@@ -140,8 +146,9 @@ export function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
-                var worker = _a.worker;
-                return worker.stop();
+                var worker = _a.worker, workerLarge = _a.workerLarge;
+                worker.stop();
+                workerLarge && workerLarge.stop();
             });
         else
             segmentsUpdateWorker.stop();
@@ -195,77 +202,96 @@ export function pushManagerFactory(params, pollingManager) {
         }
         splitsUpdateWorker.put(parsedData);
     });
-    if (userKey) {
-        pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
-            var userKeyHash = channel.split('_')[2];
-            var userKey = userKeyHashes[userKeyHash];
-            if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed
-                clients[userKey].worker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
-            }
-        });
-        pushEmitter.on(MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {
-            switch (parsedData.u) {
-                case UpdateStrategy.BoundedFetchRequest: {
-                    var bitmap_1;
-                    try {
-                        bitmap_1 = parseBitmap(parsedData.d, parsedData.c);
-                    }
-                    catch (e) {
-                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
-                        break;
-                    }
-                    forOwn(clients, function (_a) {
-                        var hash64 = _a.hash64, worker = _a.worker;
-                        if (isInBitmap(bitmap_1, hash64.hex)) {
-                            worker.put(parsedData.changeNumber); // fetch mySegments
-                        }
-                    });
-                    return;
+    function handleMySegmentsUpdate(parsedData) {
+        var isLS = parsedData.type === MY_LARGE_SEGMENTS_UPDATE;
+        switch (parsedData.u) {
+            case UpdateStrategy.BoundedFetchRequest: {
+                var bitmap_1;
+                try {
+                    bitmap_1 = parseBitmap(parsedData.d, parsedData.c);
                 }
-                case UpdateStrategy.KeyList: {
-                    var keyList = void 0, added_1, removed_1;
-                    try {
-                        keyList = parseKeyList(parsedData.d, parsedData.c);
-                        added_1 = new _Set(keyList.a);
-                        removed_1 = new _Set(keyList.r);
-                    }
-                    catch (e) {
-                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
-                        break;
+                catch (e) {
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
+                    break;
+                }
+                forOwn(clients, function (_a, matchingKey) {
+                    var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
+                    if (isInBitmap(bitmap_1, hash64.hex)) {
+                        isLS ?
+                            workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
+                            worker.put(parsedData.changeNumber);
                     }
-                    forOwn(clients, function (_a) {
-                        var hash64 = _a.hash64, worker = _a.worker;
-                        var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
-                        if (add !== undefined) {
+                });
+                return;
+            }
+            case UpdateStrategy.KeyList: {
+                var keyList = void 0, added_1, removed_1;
+                try {
+                    keyList = parseKeyList(parsedData.d, parsedData.c);
+                    added_1 = new _Set(keyList.a);
+                    removed_1 = new _Set(keyList.r);
+                }
+                catch (e) {
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
+                    break;
+                }
+                forOwn(clients, function (_a) {
+                    var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
+                    var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
+                    if (add !== undefined) {
+                        isLS ?
+                            workerLarge && workerLarge.put(parsedData.changeNumber, {
+                                name: parsedData.largeSegments[0],
+                                add: add
+                            }) :
                             worker.put(parsedData.changeNumber, {
                                 name: parsedData.segmentName,
                                 add: add
                             });
-                        }
-                    });
-                    return;
-                }
-                case UpdateStrategy.SegmentRemoval:
-                    if (!parsedData.segmentName) {
-                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
-                        break;
                     }
-                    forOwn(clients, function (_a) {
-                        var worker = _a.worker;
-                        return worker.put(parsedData.changeNumber, {
+                });
+                return;
+            }
+            case UpdateStrategy.SegmentRemoval:
+                if ((isLS && parsedData.largeSegments.length === 0) || (!isLS && !parsedData.segmentName)) {
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
+                    break;
+                }
+                forOwn(clients, function (_a) {
+                    var worker = _a.worker, workerLarge = _a.workerLarge;
+                    isLS ?
+                        workerLarge && parsedData.largeSegments.forEach(function (largeSegment) {
+                            workerLarge.put(parsedData.changeNumber, {
+                                name: largeSegment,
+                                add: false
+                            });
+                        }) :
+                        worker.put(parsedData.changeNumber, {
                             name: parsedData.segmentName,
                             add: false
                         });
-                    });
-                    return;
-            }
-            // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-            forOwn(clients, function (_a) {
-                var worker = _a.worker;
+                });
+                return;
+        }
+        // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+        forOwn(clients, function (_a, matchingKey) {
+            var worker = _a.worker, workerLarge = _a.workerLarge;
+            isLS ?
+                workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
                 worker.put(parsedData.changeNumber);
-            });
         });
     }
+    if (userKey) {
+        pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
+            var userKeyHash = channel.split('_')[2];
+            var userKey = userKeyHashes[userKeyHash];
+            if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed
+                clients[userKey].worker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
+            }
+        });
+        pushEmitter.on(MY_SEGMENTS_UPDATE_V2, handleMySegmentsUpdate);
+        pushEmitter.on(MY_LARGE_SEGMENTS_UPDATE, handleMySegmentsUpdate);
+    }
     else {
         pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker.put);
     }
@@ -287,7 +313,7 @@ export function pushManagerFactory(params, pollingManager) {
                 return;
             disconnected = false;
             if (userKey)
-                this.add(userKey, pollingManager.segmentsSyncTask); // client-side
+                this.add(userKey, pollingManager.segmentsSyncTask, pollingManager.largeSegmentsSyncTask); // client-side
             else
                 setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
         },
@@ -296,11 +322,15 @@ export function pushManagerFactory(params, pollingManager) {
             return disconnected === false;
         },
         // [Only for client-side]
-        add: function (userKey, mySegmentsSyncTask) {
+        add: function (userKey, mySegmentsSyncTask, myLargeSegmentsSyncTask) {
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) };
+                clients[userKey] = {
+                    hash64: hash64(userKey),
+                    worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_SEGMENT),
+                    workerLarge: myLargeSegmentsSyncTask ? MySegmentsUpdateWorker(myLargeSegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT) : undefined
+                };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
                 // Reconnects in case of a new client.
                 // Run in next event-loop cycle to save authentication calls

package/esm/sync/submitters/telemetrySubmitter.js

@@ -61,10 +61,12 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
             var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
             return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
+                lE: isClientSide ? settings.sync.largeSegmentsEnabled : undefined,
                 rR: {
                     sp: scheduler.featuresRefreshRate / 1000,
                     se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
                     ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+                    mls: isClientSide && settings.sync.largeSegmentsEnabled ? scheduler.largeSegmentsRefreshRate / 1000 : undefined,
                     im: scheduler.impressionsRefreshRate / 1000,
                     ev: scheduler.eventsPushRate / 1000,
                     te: scheduler.telemetryRefreshRate / 1000,

package/esm/sync/syncManagerOnline.js

@@ -2,7 +2,7 @@ import { submitterManagerFactory } from './submitters/submitterManager';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
-import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
+import { IN_LARGE_SEGMENT, IN_SEGMENT, POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -114,43 +114,53 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
             shared: function (matchingKey, readinessManager, storage) {
                 if (!pollingManager)
                     return;
-                var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
+                var _a = pollingManager.add(matchingKey, readinessManager, storage), msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
                 return {
-                    isRunning: mySegmentsSyncTask.isRunning,
+                    isRunning: msSyncTask.isRunning,
                     start: function () {
                         if (syncEnabled) {
                             if (pushManager) {
                                 if (pollingManager.isRunning()) {
                                     // if doing polling, we must start the periodic fetch of data
-                                    if (storage.splits.usesSegments())
-                                        mySegmentsSyncTask.start();
+                                    if (storage.splits.usesMatcher(IN_SEGMENT))
+                                        msSyncTask.start();
+                                    if (mlsSyncTask && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
+                                        mlsSyncTask.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();
+                                    msSyncTask.execute();
+                                    mlsSyncTask && mlsSyncTask.execute();
                                 }
-                                pushManager.add(matchingKey, mySegmentsSyncTask);
+                                pushManager.add(matchingKey, msSyncTask, mlsSyncTask);
                             }
                             else {
-                                if (storage.splits.usesSegments())
-                                    mySegmentsSyncTask.start();
+                                if (storage.splits.usesMatcher(IN_SEGMENT))
+                                    msSyncTask.start();
+                                if (mlsSyncTask && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
+                                    mlsSyncTask.start();
                             }
                         }
                         else {
-                            if (!readinessManager.isReady())
-                                mySegmentsSyncTask.execute();
+                            if (!readinessManager.isReady()) {
+                                msSyncTask.execute();
+                                mlsSyncTask && mlsSyncTask.execute();
+                            }
                         }
                     },
                     stop: function () {
                         // check in case `client.destroy()` has been invoked more than once for the same client
-                        var mySegmentsSyncTask = pollingManager.get(matchingKey);
-                        if (mySegmentsSyncTask) {
+                        var syncTasks = pollingManager.get(matchingKey);
+                        if (syncTasks) {
+                            var msSyncTask_1 = syncTasks.msSyncTask, mlsSyncTask_1 = syncTasks.mlsSyncTask;
                             // stop syncing
                             if (pushManager)
                                 pushManager.remove(matchingKey);
-                            if (mySegmentsSyncTask.isRunning())
-                                mySegmentsSyncTask.stop();
+                            if (msSyncTask_1.isRunning())
+                                msSyncTask_1.stop();
+                            if (mlsSyncTask_1 && mlsSyncTask_1.isRunning())
+                                mlsSyncTask_1.stop();
                             pollingManager.remove(matchingKey);
                         }
                     },

package/esm/utils/constants/index.js

@@ -61,6 +61,7 @@ export var TELEMETRY = 'te';
 export var TOKEN = 'to';
 export var SEGMENT = 'se';
 export var MY_SEGMENT = 'ms';
+export var MY_LARGE_SEGMENT = 'mls';
 export var TREATMENT = 't';
 export var TREATMENTS = 'ts';
 export var TREATMENT_WITH_CONFIG = 'tc';
@@ -87,3 +88,6 @@ export var DISABLED = 0;
 export var ENABLED = 1;
 export var PAUSED = 2;
 export var FLAG_SPEC_VERSION = '1.1';
+// Matcher types
+export var IN_SEGMENT = 'IN_SEGMENT';
+export var IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';

package/esm/utils/settingsValidation/index.js

@@ -5,7 +5,7 @@ import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG, FLAG_SPEC_VERSION }
 import { validImpressionsMode } from './impressionsMode';
 import { validateKey } from '../inputValidation/key';
 import { validateTrafficType } from '../inputValidation/trafficType';
-import { ERROR_MIN_CONFIG_PARAM } from '../../logger/constants';
+import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
 // Exported for telemetry
 export var base = {
     // Define which kind of object you want to retrieve from SplitFactory
@@ -27,6 +27,8 @@ export var base = {
         featuresRefreshRate: 60,
         // fetch segments updates each 60 sec
         segmentsRefreshRate: 60,
+        // fetch large segments updates each 60 sec
+        largeSegmentsRefreshRate: 60,
         // publish telemetry stats each 3600 secs (1 hour)
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
@@ -72,7 +74,8 @@ export var base = {
         impressionsMode: OPTIMIZED,
         localhostMode: undefined,
         enabled: true,
-        flagSpecVersion: FLAG_SPEC_VERSION
+        flagSpecVersion: FLAG_SPEC_VERSION,
+        largeSegmentsEnabled: false
     },
     // Logger
     log: undefined
@@ -111,6 +114,7 @@ export function settingsValidation(config, validationParams) {
     var scheduler = withDefaults.scheduler, startup = withDefaults.startup;
     scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
+    scheduler.largeSegmentsRefreshRate = fromSecondsToMillis(scheduler.largeSegmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
@@ -143,12 +147,12 @@ export function settingsValidation(config, validationParams) {
             // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
             // `false` value is used as bound key/TT of the default client, which leads to some issues.
             // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
-            withDefaults.core.key = validateKey(log, maybeKey, 'Client instantiation');
+            withDefaults.core.key = validateKey(log, maybeKey, LOG_PREFIX_CLIENT_INSTANTIATION);
         }
         if (validationParams.acceptTT) {
             var maybeTT = withDefaults.core.trafficType;
             if (maybeTT !== undefined) { // @ts-ignore
-                withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
+                withDefaults.core.trafficType = validateTrafficType(log, maybeTT, LOG_PREFIX_CLIENT_INSTANTIATION);
             }
         }
     }
@@ -183,9 +187,10 @@ export function settingsValidation(config, validationParams) {
     var splitFiltersValidation = validateSplitFilters(log, sync.splitFilters, withDefaults.mode);
     sync.splitFilters = splitFiltersValidation.validFilters;
     sync.__splitFiltersValidation = splitFiltersValidation;
+    // ensure a valid flag spec version
     sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : FLAG_SPEC_VERSION;
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop
-    withDefaults.userConsent = consent(withDefaults);
+    withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
     return withDefaults;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.16.0",
+  "version": "1.16.1-rc.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

@@ -61,6 +61,11 @@ interface IInSegmentMatcher extends ISplitMatcherBase {
   userDefinedSegmentMatcherData: IInSegmentMatcherData
 }
 
+interface IInLargeSegmentMatcher extends ISplitMatcherBase {
+  matcherType: 'IN_LARGE_SEGMENT',
+  userDefinedSegmentMatcherData: IInSegmentMatcherData
+}
+
 interface IWhitelistMatcher extends ISplitMatcherBase {
   matcherType: 'WHITELIST',
   whitelistMatcherData: IWhitelistMatcherData
@@ -165,7 +170,8 @@ interface IInListSemverMatcher extends ISplitMatcherBase {
 export type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher |
   ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher |
   IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher |
-  IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher
+  IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher |
+  IInLargeSegmentMatcher
 
 /** Split object */
 export interface ISplitPartition {
@@ -218,14 +224,18 @@ export interface ISegmentChangesResponse {
   till: number
 }
 
-export interface IMySegmentsResponseItem {
-  id: string,
-  name: string
-}
-
 /** Interface of the parsed JSON response of `/mySegments/{userKey}` */
 export interface IMySegmentsResponse {
-  mySegments: IMySegmentsResponseItem[]
+  mySegments: {
+    id: string,
+    name: string
+  }[]
+}
+
+/** Interface of the parsed JSON response of `/myLargeSegments/{userKey}` */
+export interface IMyLargeSegmentsResponse {
+  myLargeSegments: string[],
+  changeNumber: number
 }
 
 /** Metadata internal type for storages */

package/src/evaluator/matchers/index.ts

@@ -1,5 +1,6 @@
 import { allMatcherContext } from './all';
 import { segmentMatcherContext } from './segment';
+import { largeSegmentMatcherContext } from './large_segment';
 import { whitelistMatcherContext } from './whitelist';
 import { equalToMatcherContext } from './eq';
 import { greaterThanEqualMatcherContext } from './gte';
@@ -48,6 +49,7 @@ const matchers = [
   lessThanEqualToSemverMatcherContext, // LESS_THAN_OR_EQUAL_TO_SEMVER: 20
   betweenSemverMatcherContext, // BETWEEN_SEMVER: 21
   inListSemverMatcherContext, // IN_LIST_SEMVER: 22
+  largeSegmentMatcherContext, // IN_LARGE_SEGMENT: 23
 ];
 
 /**

package/src/evaluator/matchers/large_segment.ts

@@ -0,0 +1,18 @@
+import { MaybeThenable } from '../../dtos/types';
+import { ISegmentsCacheBase } from '../../storages/types';
+import { thenable } from '../../utils/promise/thenable';
+
+export function largeSegmentMatcherContext(largeSegmentName: string, storage: { largeSegments?: ISegmentsCacheBase }) {
+
+  return function largeSegmentMatcher(key: string): MaybeThenable<boolean> {
+    const isInLargeSegment = storage.largeSegments ? storage.largeSegments.isInSegment(largeSegmentName, key) : false;
+
+    if (thenable(isInLargeSegment)) {
+      isInLargeSegment.then(result => {
+        return result;
+      });
+    }
+
+    return isInLargeSegment;
+  };
+}

package/src/evaluator/matchers/matcherTypes.ts

@@ -22,6 +22,7 @@ export const matcherTypes: Record<string, number> = {
   LESS_THAN_OR_EQUAL_TO_SEMVER: 20,
   BETWEEN_SEMVER: 21,
   IN_LIST_SEMVER: 22,
+  IN_LARGE_SEGMENT: 23,
 };
 
 export const matcherDataTypes = {

package/src/evaluator/matchersTransform/index.ts

@@ -33,7 +33,7 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
     let dataType = matcherDataTypes.STRING;
     let value = undefined;
 
-    if (type === matcherTypes.IN_SEGMENT) {
+    if (type === matcherTypes.IN_SEGMENT || type === matcherTypes.IN_LARGE_SEGMENT) {
       value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
     } else if (type === matcherTypes.EQUAL_TO) {
       value = numericTransform(unaryNumericMatcherData as IUnaryNumericMatcherData);

package/src/logger/constants.ts

@@ -36,7 +36,6 @@ export const IMPRESSION = 102;
 export const IMPRESSION_QUEUEING = 103;
 export const NEW_SHARED_CLIENT = 104;
 export const NEW_FACTORY = 105;
-export const POLLING_SMART_PAUSING = 106;
 export const POLLING_START = 107;
 export const POLLING_STOP = 108;
 export const SYNC_SPLITS_FETCH_RETRY = 109;
@@ -120,6 +119,7 @@ export const ENGINE_MATCHER_ERROR = 329;
 // Log prefixes (a.k.a. tags or categories)
 export const LOG_PREFIX_SETTINGS = 'settings';
 export const LOG_PREFIX_INSTANTIATION = 'Factory instantiation';
+export const LOG_PREFIX_CLIENT_INSTANTIATION = 'Client instantiation';
 export const LOG_PREFIX_ENGINE = 'engine';
 export const LOG_PREFIX_ENGINE_COMBINER = LOG_PREFIX_ENGINE + ':combiner: ';
 export const LOG_PREFIX_ENGINE_MATCHER = LOG_PREFIX_ENGINE + ':matcher: ';

package/src/logger/messages/info.ts

@@ -19,7 +19,6 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.USER_CONSENT_INITIAL, 'Starting the SDK with %s user consent. No data will be sent.'],
 
   // synchronizer
-  [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],
   [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
   [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
   [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of feature flags #%s. Reason: %s'],

package/src/readiness/readinessManager.ts

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IEventEmitter } from '../types';
+import { IEventEmitter, ISettings } from '../types';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
 import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
 
@@ -18,10 +18,8 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   return splitsEventEmitter;
 }
 
-function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISegmentsEventEmitter {
-  const segmentsEventEmitter = objectAssign(new EventEmitter(), {
-    segmentsArrived: false
-  });
+function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter, segmentsArrived = false): ISegmentsEventEmitter {
+  const segmentsEventEmitter = objectAssign(new EventEmitter(), { segmentsArrived });
 
   segmentsEventEmitter.once(SDK_SEGMENTS_ARRIVED, () => { segmentsEventEmitter.segmentsArrived = true; });
 
@@ -33,10 +31,13 @@ function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISe
  */
 export function readinessManagerFactory(
   EventEmitter: new () => IEventEmitter,
-  readyTimeout = 0,
+  settings: ISettings,
   splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter)): IReadinessManager {
 
+  const { startup: { readyTimeout, waitForLargeSegments }, sync: { largeSegmentsEnabled } } = settings;
+
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
+  const largeSegments = largeSegmentsEnabled ? segmentsEventEmitterFactory(EventEmitter, !waitForLargeSegments) : undefined;
   const gate: IReadinessEventEmitter = new EventEmitter();
 
   // emit SDK_READY_FROM_CACHE
@@ -62,6 +63,7 @@ export function readinessManagerFactory(
   let isReady = false;
   splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
   segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
+  if (largeSegments) largeSegments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
 
   let isDestroyed = false;
 
@@ -87,7 +89,7 @@ export function readinessManagerFactory(
         setTimeout(() => { throw e; }, 0);
       }
     } else {
-      if (splits.splitsArrived && segments.segmentsArrived) {
+      if (splits.splitsArrived && segments.segmentsArrived && (!largeSegments || largeSegments.segmentsArrived)) {
         clearTimeout(readyTimeoutId);
         isReady = true;
         try {
@@ -105,11 +107,12 @@ export function readinessManagerFactory(
   return {
     splits,
     segments,
+    largeSegments,
     gate,
 
-    shared(readyTimeout = 0) {
+    shared() {
       refCount++;
-      return readinessManagerFactory(EventEmitter, readyTimeout, splits);
+      return readinessManagerFactory(EventEmitter, settings, splits);
     },
 
     // @TODO review/remove next methods when non-recoverable errors are reworked
@@ -123,6 +126,7 @@ export function readinessManagerFactory(
       isDestroyed = true;
 
       segments.removeAllListeners();
+      if (largeSegments) largeSegments.removeAllListeners();
       gate.removeAllListeners();
       clearTimeout(readyTimeoutId);
 

package/src/readiness/sdkReadinessManager.ts

@@ -2,9 +2,8 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter } from '../types';
+import { IEventEmitter, ISettings } from '../types';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ILogger } from '../logger/types';
 import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
 
 const NEW_LISTENER_EVENT = 'newListener';
@@ -18,10 +17,11 @@ const REMOVE_LISTENER_EVENT = 'removeListener';
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
 export function sdkReadinessManagerFactory(
-  log: ILogger,
   EventEmitter: new () => IEventEmitter,
-  readyTimeout = 0,
-  readinessManager = readinessManagerFactory(EventEmitter, readyTimeout)): ISdkReadinessManager {
+  settings: ISettings,
+  readinessManager = readinessManagerFactory(EventEmitter, settings)): ISdkReadinessManager {
+
+  const log = settings.log;
 
   /** Ready callback warning */
   let internalReadyCbCount = 0;
@@ -72,8 +72,8 @@ export function sdkReadinessManagerFactory(
   return {
     readinessManager,
 
-    shared(readyTimeout = 0) {
-      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
+    shared() {
+      return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
     },
 
     incInternalReadyCbCount() {