@splitsoftware/splitio-commons 1.16.1-rc.8 → 1.17.0-rc.1

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,8 +1,7 @@
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
 import { ISet, _Set } from '../../utils/lang/sets';
-import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -14,8 +13,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
   private splitsCache: Record<string, ISplit> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
-  private segmentsCount: number = 0;
-  private largeSegmentsCount: number = 0;
+  private splitsWithSegmentsCount: number = 0;
   private flagSetsCache: Record<string, ISet<string>> = {};
 
   constructor(splitFiltersValidation?: ISplitFiltersValidation) {
@@ -27,8 +25,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.splitsCache = {};
     this.ttCache = {};
     this.changeNumber = -1;
-    this.segmentsCount = 0;
-    this.largeSegmentsCount = 0;
+    this.splitsWithSegmentsCount = 0;
   }
 
   addSplit(name: string, split: ISplit): boolean {
@@ -41,9 +38,9 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
       this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
 
-      // Substract from segments count for the previous version of this Split.
-      if (usesMatcher(previousSplit, IN_SEGMENT)) this.segmentsCount--;
-      if (usesMatcher(previousSplit, IN_LARGE_SEGMENT)) this.largeSegmentsCount--;
+      if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
+        this.splitsWithSegmentsCount--;
+      }
     }
 
     if (split) {
@@ -55,8 +52,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.addToFlagSets(split);
 
       // Add to segments count for the new version of the Split
-      if (usesMatcher(split, IN_SEGMENT)) this.segmentsCount++;
-      if (usesMatcher(split, IN_LARGE_SEGMENT)) this.largeSegmentsCount++;
+      if (usesSegments(split)) this.splitsWithSegmentsCount++;
 
       return true;
     } else {
@@ -76,8 +72,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.removeFromFlagSets(split.name, split.sets);
 
       // Update the segments count.
-      if (usesMatcher(split, IN_SEGMENT)) this.segmentsCount--;
-      if (usesMatcher(split, IN_LARGE_SEGMENT)) this.largeSegmentsCount--;
+      if (usesSegments(split)) this.splitsWithSegmentsCount--;
 
       return true;
     } else {
@@ -106,8 +101,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
   }
 
-  usesMatcher(matcherType: string): boolean {
-    return this.getChangeNumber() === -1 || (matcherType === IN_SEGMENT ? this.segmentsCount > 0 : this.largeSegmentsCount > 0);
+  usesSegments(): boolean {
+    return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
   }
 
   getNamesByFlagSets(flagSets: string[]): ISet<string>[] {

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload, UpdatesFromSSEEnum, UpdatesFromSSE } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../../sync/submitters/types';
 import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
@@ -25,7 +25,7 @@ export function shouldRecordTelemetry({ settings }: IStorageFactoryParams) {
 
 export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
-  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync, private largeSegments?: ISegmentsCacheSync) { }
+  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync) { }
 
   // isEmpty flag
   private e = true;
@@ -51,8 +51,6 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
       spC: this.splits && this.splits.getSplitNames().length,
       seC: this.segments && this.segments.getRegisteredSegments().length,
       skC: this.segments && this.segments.getKeysCount(),
-      lseC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
-      lskC: this.largeSegments && this.largeSegments.getKeysCount(),
       sL: this.getSessionLength(),
       eQ: this.getEventStats(QUEUED),
       eD: this.getEventStats(DROPPED),
@@ -247,16 +245,22 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     this.e = false;
   }
 
-  private updatesFromSSE: UpdatesFromSSE = {};
+  private updatesFromSSE = {
+    sp: 0,
+    ms: 0
+  };
 
   popUpdatesFromSSE() {
     const result = this.updatesFromSSE;
-    this.updatesFromSSE = {};
+    this.updatesFromSSE = {
+      sp: 0,
+      ms: 0,
+    };
     return result;
   }
 
   recordUpdatesFromSSE(type: UpdatesFromSSEEnum) {
-    this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
+    this.updatesFromSSE[type]++;
     this.e = false;
   }
 

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -7,7 +7,7 @@ import { ISet, setToArray, _Set } from '../../utils/lang/sets';
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
- * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
  */
 export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | ISet<string>>, _setConnDelay(connDelay: number): void } {
 

package/src/storages/types.ts

@@ -204,8 +204,8 @@ export interface ISplitsCacheBase {
   getSplitNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
-  // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === 1) or contains a FF using the given matcher
-  usesMatcher(matcherType: string): MaybeThenable<boolean>,
+  // only for Client-Side
+  usesSegments(): MaybeThenable<boolean>,
   clear(): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
   checkCache(): MaybeThenable<boolean>,
@@ -223,7 +223,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   getAll(): ISplit[],
   getSplitNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
-  usesMatcher(matcherType: string): boolean,
+  usesSegments(): boolean,
   clear(): void,
   checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
@@ -240,7 +240,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   getAll(): Promise<ISplit[]>,
   getSplitNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
-  usesMatcher(matcherType: string): Promise<boolean>,
+  usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
   checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
@@ -477,9 +477,7 @@ export interface IStorageSync extends IStorageBase<
   IEventsCacheSync,
   ITelemetryCacheSync,
   IUniqueKeysCacheSync
-> {
-  largeSegments?: ISegmentsCacheSync,
-}
+> { }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,

package/src/sync/polling/fetchers/mySegmentsFetcher.ts

@@ -1,5 +1,5 @@
 import { IFetchMySegments, IResponse } from '../../../services/types';
-import { IMySegmentsResponse, IMyLargeSegmentsResponse } from '../../../dtos/types';
+import { IMySegmentsResponseItem } from '../../../dtos/types';
 import { IMySegmentsFetcher } from './types';
 
 /**
@@ -21,11 +21,7 @@ export function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments): IMy
     // Extract segment names
     return mySegmentsPromise
       .then(resp => resp.json())
-      .then((json: IMySegmentsResponse | IMyLargeSegmentsResponse) => {
-        return (json as IMySegmentsResponse).mySegments ?
-          (json as IMySegmentsResponse).mySegments.map((segment) => segment.name) :
-          (json as IMyLargeSegmentsResponse).myLargeSegments;
-      });
+      .then(json => json.mySegments.map((segment: IMySegmentsResponseItem) => segment.name));
   };
 
 }

package/src/sync/polling/pollingManagerCS.ts

@@ -6,9 +6,8 @@ import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
-import { POLLING_START, POLLING_STOP } from '../../logger/constants';
+import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 
 /**
  * Expose start / stop mechanism for polling data from services.
@@ -23,92 +22,62 @@ export function pollingManagerCSFactory(
 
   const splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
 
-  // Map of matching keys to their corresponding MySegmentsSyncTask for segments and large segments.
-  const mySegmentsSyncTasks: Record<string, { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }> = {};
+  // Map of matching keys to their corresponding MySegmentsSyncTask.
+  const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
 
   const matchingKey = getMatching(settings.core.key);
-  const { msSyncTask, mlsSyncTask } = add(matchingKey, readiness, storage);
+  const mySegmentsSyncTask = add(matchingKey, readiness, storage);
 
   function startMySegmentsSyncTasks() {
-    const splitsHaveSegments = storage.splits.usesMatcher(IN_SEGMENT);
-    const splitsHaveLargeSegments = storage.splits.usesMatcher(IN_LARGE_SEGMENT);
-
-    forOwn(mySegmentsSyncTasks, ({ msSyncTask, mlsSyncTask }) => {
-      if (splitsHaveSegments) msSyncTask.start();
-      else msSyncTask.stop(); // smart pausing
-
-      if (mlsSyncTask) {
-        if (splitsHaveLargeSegments) mlsSyncTask.start();
-        else mlsSyncTask.stop(); // smart pausing
-      }
+    forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+      mySegmentsSyncTask.start();
     });
   }
 
   function stopMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, ({ msSyncTask, mlsSyncTask }) => {
-      msSyncTask.stop();
-      mlsSyncTask && mlsSyncTask.stop();
+    forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+      if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
     });
   }
 
+  // smart pausing
   readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
-    if (splitsSyncTask.isRunning()) startMySegmentsSyncTasks();
+    if (!splitsSyncTask.isRunning()) return; // noop if not doing polling
+    const splitsHaveSegments = storage.splits.usesSegments();
+    if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
+      log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);
+      if (splitsHaveSegments) {
+        startMySegmentsSyncTasks();
+      } else {
+        stopMySegmentsSyncTasks();
+      }
+    }
   });
 
   function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
-    const msSyncTask = mySegmentsSyncTaskFactory(
-      splitApi.fetchMySegments,
-      storage.segments,
-      () => { if (storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED); },
-      settings,
-      matchingKey,
-      settings.scheduler.segmentsRefreshRate,
-      'mySegmentsUpdater'
-    );
-
-    let mlsSyncTask;
-    if (settings.sync.largeSegmentsEnabled) {
-      mlsSyncTask = mySegmentsSyncTaskFactory(
-        splitApi.fetchMyLargeSegments,
-        storage.largeSegments!,
-        () => { if (readiness.largeSegments && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED); },
-        settings,
-        matchingKey,
-        settings.scheduler.largeSegmentsRefreshRate,
-        'myLargeSegmentsUpdater'
-      );
-    }
+    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
 
     // smart ready
     function smartReady() {
-      if (!readiness.isReady()) {
-        if (readiness.largeSegments && !storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED);
-        if (!storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-      }
+      if (!readiness.isReady() && !storage.splits.usesSegments()) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     }
+    if (!storage.splits.usesSegments()) setTimeout(smartReady, 0);
+    else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
 
-    if (storage.splits.usesMatcher(IN_SEGMENT) && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
-    else setTimeout(smartReady, 0);
-
-    mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
-
-    return {
-      msSyncTask,
-      mlsSyncTask
-    };
+    mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+    return mySegmentsSyncTask;
   }
 
   return {
     splitsSyncTask,
-    segmentsSyncTask: msSyncTask,
-    largeSegmentsSyncTask: mlsSyncTask,
+    segmentsSyncTask: mySegmentsSyncTask,
 
     // Start periodic fetching (polling)
     start() {
       log.info(POLLING_START);
 
       splitsSyncTask.start();
-      startMySegmentsSyncTasks();
+      if (storage.splits.usesSegments()) startMySegmentsSyncTasks();
     },
 
     // Stop periodic fetching (polling)
@@ -125,9 +94,8 @@ export function pollingManagerCSFactory(
     // fetch splits and segments
     syncAll() {
       const promises = [splitsSyncTask.execute()];
-      forOwn(mySegmentsSyncTasks, function ({ msSyncTask, mlsSyncTask }) {
-        promises.push(msSyncTask.execute());
-        mlsSyncTask && promises.push(mlsSyncTask.execute());
+      forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+        promises.push(mySegmentsSyncTask.execute());
       });
       return Promise.all(promises);
     },

package/src/sync/polling/syncTasks/mySegmentsSyncTask.ts

@@ -1,4 +1,5 @@
-import { ISegmentsCacheSync } from '../../../storages/types';
+import { IStorageSync } from '../../../storages/types';
+import { IReadinessManager } from '../../../readiness/types';
 import { syncTaskFactory } from '../../syncTask';
 import { IMySegmentsSyncTask } from '../types';
 import { IFetchMySegments } from '../../../services/types';
@@ -11,25 +12,24 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
  */
 export function mySegmentsSyncTaskFactory(
   fetchMySegments: IFetchMySegments,
-  mySegmentsCache: ISegmentsCacheSync,
-  notifyUpdate: () => void,
+  storage: IStorageSync,
+  readiness: IReadinessManager,
   settings: ISettings,
-  matchingKey: string,
-  segmentsRefreshRate: number,
-  NAME: string
+  matchingKey: string
 ): IMySegmentsSyncTask {
   return syncTaskFactory(
     settings.log,
     mySegmentsUpdaterFactory(
       settings.log,
       mySegmentsFetcherFactory(fetchMySegments),
-      mySegmentsCache,
-      notifyUpdate,
+      storage.splits,
+      storage.segments,
+      readiness.segments,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
       matchingKey
     ),
-    segmentsRefreshRate,
-    NAME,
+    settings.scheduler.segmentsRefreshRate,
+    'mySegmentsUpdater',
   );
 }

package/src/sync/polling/types.ts

@@ -12,7 +12,7 @@ export type MySegmentsData = string[] | {
   name: string,
   /* action: `true` for add, and `false` for delete */
   add: boolean
-}[]
+}
 
 export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
 
@@ -20,14 +20,13 @@ export interface IPollingManager extends ITask {
   syncAll(): Promise<any>
   splitsSyncTask: ISplitsSyncTask
   segmentsSyncTask: ISyncTask
-  largeSegmentsSyncTask?: ISyncTask
 }
 
 /**
  * PollingManager for client-side with support for multiple clients
  */
 export interface IPollingManagerCS extends IPollingManager {
-  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }
+  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask
   remove(matchingKey: string): void;
-  get(matchingKey: string): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask } | undefined
+  get(matchingKey: string): IMySegmentsSyncTask | undefined
 }

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

@@ -1,12 +1,13 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync } from '../../../storages/types';
+import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
+import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
+import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
-import { isObject } from '../../../utils/lang';
 
-type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>
+type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>
 
 /**
  * factory of MySegments updater, a task that:
@@ -17,8 +18,9 @@ type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => P
 export function mySegmentsUpdaterFactory(
   log: ILogger,
   mySegmentsFetcher: IMySegmentsFetcher,
+  splitsCache: ISplitsCacheSync,
   mySegmentsCache: ISegmentsCacheSync,
-  notifyUpdate: () => void,
+  segmentsEventEmitter: ISegmentsEventEmitter,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
   matchingKey: string
@@ -37,24 +39,25 @@ export function mySegmentsUpdaterFactory(
   function updateSegments(segmentsData: MySegmentsData) {
 
     let shouldNotifyUpdate;
-    if (isObject(segmentsData[0])) {
-      // Add/Delete the segment names
-      (segmentsData as { name: string, add: boolean }[]).forEach(({ name, add }) => {
-        if (mySegmentsCache.isInSegment(name) !== add) {
-          shouldNotifyUpdate = true;
-          if (add) mySegmentsCache.addToSegment(name);
-          else mySegmentsCache.removeFromSegment(name);
-        }
-      });
+    if (Array.isArray(segmentsData)) {
+      // Update the list of segment names available
+      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
     } else {
-      // Reset the list of segment names
-      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData as string[]);
+      // Add/Delete the segment
+      const { name, add } = segmentsData;
+      if (mySegmentsCache.isInSegment(name) !== add) {
+        shouldNotifyUpdate = true;
+        if (add) mySegmentsCache.addToSegment(name);
+        else mySegmentsCache.removeFromSegment(name);
+      } else {
+        shouldNotifyUpdate = false;
+      }
     }
 
     // Notify update if required
-    if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
+    if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
-      notifyUpdate();
+      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
     }
   }
 

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

@@ -1,7 +1,8 @@
 import { IPlatform } from '../../../sdkFactory/types';
+import { decorateHeaders } from '../../../services/decorateHeaders';
 import { IEventSourceConstructor } from '../../../services/types';
 import { ISettings } from '../../../types';
-import { endsWith, isString } from '../../../utils/lang';
+import { isString } from '../../../utils/lang';
 import { objectAssign } from '../../../utils/lang/objectAssign';
 import { IAuthTokenPushEnabled } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
@@ -36,33 +37,25 @@ function buildSSEHeaders(settings: ISettings) {
 export class SSEClient implements ISSEClient {
   // Instance properties:
   eventSource?: IEventSourceConstructor;
-  streamingUrl: string;
   connection?: InstanceType<IEventSourceConstructor>;
   handler?: ISseEventHandler;
-  useHeaders?: boolean;
   headers: Record<string, string>;
   options?: object;
-  lse?: boolean;
 
   /**
    * SSEClient constructor.
    *
    * @param settings Validated settings.
-   * @param useHeaders True to send metadata as headers or false to send as query params. If `true`, the provided EventSource must support headers.
    * @param platform object containing environment-specific dependencies
    * @throws 'EventSource API is not available.' if EventSource is not available.
    */
-  constructor(settings: ISettings, useHeaders: boolean, { getEventSource, getOptions }: IPlatform) {
+  constructor(private settings: ISettings, { getEventSource, getOptions }: IPlatform) {
     this.eventSource = getEventSource && getEventSource(settings);
     // if eventSource is not available, throw an exception
     if (!this.eventSource) throw new Error('EventSource API is not available.');
 
-    this.streamingUrl = settings.urls.streaming + '/sse';
-    // @TODO get `useHeaders` flag from `getEventSource`, to use EventSource headers on client-side SDKs when possible.
-    this.useHeaders = useHeaders;
     this.headers = buildSSEHeaders(settings);
     this.options = getOptions && getOptions(settings);
-    this.lse = settings.sync.largeSegmentsEnabled;
   }
 
   setEventHandler(handler: ISseEventHandler) {
@@ -78,21 +71,22 @@ export class SSEClient implements ISSEClient {
   open(authToken: IAuthTokenPushEnabled) {
     this.close(); // it closes connection if previously opened
 
-    const channelsQueryParam = Object.keys(authToken.channels).map((channel) => {
-      const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
-      return encodeURIComponent(params + channel);
-    }).filter(channel => {
-      return this.lse || !endsWith(channel, 'myLargeSegments');
-    }).join(',');
-
-    const url = `${this.streamingUrl}?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${ABLY_API_VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
+    const channelsQueryParam = Object.keys(authToken.channels).map(
+      function (channel) {
+        const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
+        return encodeURIComponent(params + channel);
+      }
+    ).join(',');
+    const url = `${this.settings.urls.streaming}/sse?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${ABLY_API_VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
+    // use headers in server-side or if getHeaderOverrides is defined
+    const useHeaders = !this.settings.core.key || this.settings.sync.requestOptions?.getHeaderOverrides;
 
     this.connection = new this.eventSource!(
       // For client-side SDKs, SplitSDKClientKey and SplitSDKClientKey metadata is passed as query params,
       // because native EventSource implementations for browser doesn't support headers.
-      this.useHeaders ? url : url + `&SplitSDKVersion=${this.headers.SplitSDKVersion}&SplitSDKClientKey=${this.headers.SplitSDKClientKey}`,
+      useHeaders ? url : url + `&SplitSDKVersion=${this.headers.SplitSDKVersion}&SplitSDKClientKey=${this.headers.SplitSDKClientKey}`,
       // For server-side SDKs, metadata is passed via headers. EventSource must support headers, like 'eventsource' package for Node.
-      objectAssign(this.useHeaders ? { headers: this.headers } : {}, this.options)
+      objectAssign(useHeaders ? { headers: decorateHeaders(this.settings, this.headers) } : {}, this.options)
     );
 
     if (this.handler) { // no need to check if SSEClient is used only by PushManager

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, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -83,7 +83,6 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
         case SPLIT_UPDATE:
         case SEGMENT_UPDATE:
         case MY_SEGMENTS_UPDATE_V2:
-        case MY_LARGE_SEGMENTS_UPDATE:
         case SPLIT_KILL:
           pushEmitter.emit(parsedData.type, parsedData);
           break;

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

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_UPDATE } from '../types';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
 
 export interface IMySegmentsUpdateData {
   type: MY_SEGMENTS_UPDATE,
@@ -35,18 +35,6 @@ export interface IMySegmentsUpdateV2Data {
   u: UpdateStrategy,
 }
 
-export interface IMyLargeSegmentsUpdateData {
-  type: MY_LARGE_SEGMENTS_UPDATE,
-  changeNumber: number,
-  largeSegments: string[],
-  c: Compression,
-  d: string,
-  u: UpdateStrategy,
-  i?: number, // time interval in millis
-  h?: number, // hash function
-  s?: number, // seed for hash function
-}
-
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,
   changeNumber: number,
@@ -80,6 +68,6 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
+export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
 export type INotificationMessage = { parsedData: INotificationData, channel: string, timestamp: number, data: string }
 export type INotificationError = Event & { parsedData?: any, message?: string }