@splitsoftware/splitio-commons 1.17.1-rc.4 → 1.17.1

package/src/readiness/readinessManager.ts

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } 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';
 
@@ -7,12 +7,10 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   const splitsEventEmitter = objectAssign(new EventEmitter(), {
     splitsArrived: false,
     splitsCacheLoaded: false,
-    initialized: false,
-    initCallbacks: []
   });
 
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
-  // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
+  // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
   // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
   splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
   splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
@@ -35,11 +33,9 @@ function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISe
  */
 export function readinessManagerFactory(
   EventEmitter: new () => IEventEmitter,
-  settings: ISettings,
+  readyTimeout = 0,
   splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter)): IReadinessManager {
 
-  const readyTimeout = settings.startup.readyTimeout;
-
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
   const gate: IReadinessEventEmitter = new EventEmitter();
 
@@ -58,8 +54,8 @@ export function readinessManagerFactory(
   // emit SDK_READY_TIMED_OUT
   let hasTimedout = false;
 
-  function timeout() { // eslint-disable-next-line no-use-before-define
-    if (hasTimedout || isReady) return;
+  function timeout() {
+    if (hasTimedout) return;
     hasTimedout = true;
     syncLastUpdate();
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
@@ -67,8 +63,7 @@ export function readinessManagerFactory(
 
   let readyTimeoutId: ReturnType<typeof setTimeout>;
   if (readyTimeout > 0) {
-    if (splits.initialized) readyTimeoutId = setTimeout(timeout, readyTimeout);
-    else splits.initCallbacks.push(() => { readyTimeoutId = setTimeout(timeout, readyTimeout); });
+    readyTimeoutId = setTimeout(timeout, readyTimeout);
   }
 
   // emit SDK_READY and SDK_UPDATE
@@ -123,9 +118,9 @@ export function readinessManagerFactory(
     segments,
     gate,
 
-    shared() {
+    shared(readyTimeout = 0) {
       refCount++;
-      return readinessManagerFactory(EventEmitter, settings, splits);
+      return readinessManagerFactory(EventEmitter, readyTimeout, splits);
     },
 
     // @TODO review/remove next methods when non-recoverable errors are reworked
@@ -135,12 +130,6 @@ export function readinessManagerFactory(
     // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
     setDestroyed() { isDestroyed = true; },
 
-    init() {
-      if (splits.initialized) return;
-      splits.initialized = true;
-      splits.initCallbacks.forEach(cb => cb());
-    },
-
     destroy() {
       isDestroyed = true;
       syncLastUpdate();

package/src/readiness/sdkReadinessManager.ts

@@ -2,8 +2,9 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } 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';
@@ -17,11 +18,10 @@ 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,
-  settings: ISettings,
-  readinessManager = readinessManagerFactory(EventEmitter, settings)): ISdkReadinessManager {
-
-  const log = settings.log;
+  readyTimeout = 0,
+  readinessManager = readinessManagerFactory(EventEmitter, readyTimeout)): ISdkReadinessManager {
 
   /** Ready callback warning */
   let internalReadyCbCount = 0;
@@ -72,8 +72,8 @@ export function sdkReadinessManagerFactory(
   return {
     readinessManager,
 
-    shared() {
-      return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
+    shared(readyTimeout = 0) {
+      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
     },
 
     incInternalReadyCbCount() {

package/src/readiness/types.ts

@@ -12,8 +12,6 @@ export interface ISplitsEventEmitter extends IEventEmitter {
   once(event: ISplitsEvent, listener: (...args: any[]) => void): this;
   splitsArrived: boolean
   splitsCacheLoaded: boolean
-  initialized: boolean,
-  initCallbacks: (() => void)[]
 }
 
 /** Segments data emitter */
@@ -61,10 +59,9 @@ export interface IReadinessManager {
   timeout(): void,
   setDestroyed(): void,
   destroy(): void,
-  init(): void,
 
   /** for client-side */
-  shared(): IReadinessManager,
+  shared(readyTimeout?: number): IReadinessManager,
 }
 
 /** SDK readiness manager */
@@ -80,5 +77,5 @@ export interface ISdkReadinessManager {
   incInternalReadyCbCount(): void
 
   /** for client-side */
-  shared(): ISdkReadinessManager
+  shared(readyTimeout?: number): ISdkReadinessManager
 }

package/src/sdkClient/sdkClient.ts

@@ -66,11 +66,11 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
         syncManager && syncManager.stop();
 
         return __flush().then(() => {
-          // For main client, cleanup event listeners and scheduled jobs
-          if (!isSharedClient) {
-            signalListener && signalListener.stop();
-            uniqueKeysTracker && uniqueKeysTracker.stop();
-          }
+          // Cleanup event listeners
+          signalListener && signalListener.stop();
+
+          // @TODO stop only if last client is destroyed
+          if (uniqueKeysTracker) uniqueKeysTracker.stop();
 
           // Cleanup storage
           return storage.destroy();

package/src/sdkClient/sdkClientMethod.ts

@@ -4,15 +4,12 @@ import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
- * Factory of client method for server-side SDKs
+ * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
 export function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient {
   const log = params.settings.log;
   const clientInstance = sdkClientFactory(params);
 
-  // Only one client in server-side without bound key
-  params.clients[''] = clientInstance;
-
   return function client() {
     if (arguments.length > 0) {
       throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');

package/src/sdkClient/sdkClientMethodCS.ts

@@ -8,14 +8,18 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-import { buildInstanceId } from './identity';
+
+function buildInstanceId(key: SplitIO.SplitKey) {
+  // @ts-ignore
+  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-`;
+}
 
 /**
  * Factory of client method for the client-side API variant where TT is ignored.
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log } } = params;
+  const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -27,7 +31,8 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
   const defaultInstanceId = buildInstanceId(parsedDefaultKey);
 
   // Cache instances created per factory.
-  clients[defaultInstanceId] = mainClientInstance;
+  const clientInstances: Record<string, SplitIO.ICsClient> = {};
+  clientInstances[defaultInstanceId] = mainClientInstance;
 
   return function client(key?: SplitIO.SplitKey) {
     if (key === undefined) {
@@ -43,10 +48,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
     const instanceId = buildInstanceId(validKey);
 
-    if (!clients[instanceId]) {
+    if (!clientInstances[instanceId]) {
       const matchingKey = getMatching(validKey);
 
-      const sharedSdkReadiness = sdkReadinessManager.shared();
+      const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
       const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
         if (err) {
           sharedSdkReadiness.readinessManager.timeout();
@@ -65,21 +70,24 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
-      clients[instanceId] = clientCSDecorator(
+      clientInstances[instanceId] = clientCSDecorator(
         log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
+          signalListener: undefined, // only the main client "destroy" method stops the signal listener
         }), true) as SplitIO.IClient,
         validKey
       );
 
+      sharedSyncManager && sharedSyncManager.start();
+
       log.info(NEW_SHARED_CLIENT);
     } else {
       log.debug(RETRIEVE_CLIENT_EXISTING);
     }
 
-    return clients[instanceId] as SplitIO.ICsClient;
+    return clientInstances[instanceId];
   };
 }

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -9,7 +9,11 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-import { buildInstanceId } from './identity';
+
+function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
+  // @ts-ignore
+  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType !== undefined ? trafficType : ''}`;
+}
 
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
@@ -17,7 +21,7 @@ import { buildInstanceId } from './identity';
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log } } = params;
+  const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -30,7 +34,8 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
   const defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
 
   // Cache instances created per factory.
-  clients[defaultInstanceId] = mainClientInstance;
+  const clientInstances: Record<string, SplitIO.ICsClient> = {};
+  clientInstances[defaultInstanceId] = mainClientInstance;
 
   return function client(key?: SplitIO.SplitKey, trafficType?: string) {
     if (key === undefined) {
@@ -53,10 +58,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
     }
     const instanceId = buildInstanceId(validKey, validTrafficType);
 
-    if (!clients[instanceId]) {
+    if (!clientInstances[instanceId]) {
       const matchingKey = getMatching(validKey);
 
-      const sharedSdkReadiness = sdkReadinessManager.shared();
+      const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
       const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
         if (err) {
           sharedSdkReadiness.readinessManager.timeout();
@@ -75,22 +80,25 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
-      clients[instanceId] = clientCSDecorator(
+      clientInstances[instanceId] = clientCSDecorator(
         log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
+          signalListener: undefined, // only the main client "destroy" method stops the signal listener
         }), true) as SplitIO.IClient,
         validKey,
         validTrafficType
       );
 
+      sharedSyncManager && sharedSyncManager.start();
+
       log.info(NEW_SHARED_CLIENT);
     } else {
       log.debug(RETRIEVE_CLIENT_EXISTING);
     }
 
-    return clients[instanceId] as SplitIO.ICsClient;
+    return clientInstances[instanceId];
   };
 }

package/src/sdkFactory/index.ts

@@ -3,7 +3,7 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { IBasicClient, SplitIO } from '../types';
+import { SplitIO } from '../types';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
@@ -23,22 +23,16 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory, lazyInit } = params;
+    filterAdapterFactory } = params;
   const { log, sync: { impressionsMode } } = settings;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
 
-  // initialization
-  let hasInit = false;
-  const initCallbacks: (() => void)[] = [];
+  // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+  validateAndTrackApiKey(log, settings.core.authorizationKey);
 
-  function whenInit(cb: () => void) {
-    if (hasInit) cb();
-    else initCallbacks.push(cb);
-  }
-
-  const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
+  const sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
   const readiness = sdkReadinessManager.readinessManager;
 
   const storage = storageFactory({
@@ -54,7 +48,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     },
   });
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
-  const clients: Record<string, IBasicClient> = {};
+
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
@@ -73,13 +67,13 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       strategy = strategyDebugFactory(observer);
   }
 
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
+  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;
@@ -91,21 +85,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const clientMethod = sdkClientMethodFactory(ctx);
   const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
 
-
-  function init() {
-    if (hasInit) return;
-    hasInit = true;
-
-    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-    validateAndTrackApiKey(log, settings.core.authorizationKey);
-    readiness.init();
-    uniqueKeysTracker && uniqueKeysTracker.start();
-    syncManager && syncManager.start();
-    signalListener && signalListener.start();
-
-    initCallbacks.forEach((cb) => cb());
-    initCallbacks.length = 0;
-  }
+  syncManager && syncManager.start();
+  signalListener && signalListener.start();
 
   log.info(NEW_FACTORY);
 
@@ -124,9 +105,5 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     Logger: createLoggerAPI(log),
 
     settings,
-
-    destroy() {
-      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
-    }
-  }, extraProps && extraProps(ctx), lazyInit ? { init } : init());
+  }, extraProps && extraProps(ctx));
 }

package/src/sdkFactory/types.ts

@@ -8,7 +8,7 @@ import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
-import { SplitIO, ISettings, IEventEmitter, IBasicClient } from '../types';
+import { SplitIO, ISettings, IEventEmitter } from '../types';
 
 /**
  * Environment related dependencies.
@@ -49,7 +49,6 @@ export interface ISdkFactoryContext {
   signalListener?: ISignalListener
   splitApi?: ISplitApi
   syncManager?: ISyncManager,
-  clients: Record<string, IBasicClient>,
 }
 
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {
@@ -68,8 +67,6 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
-  // If true, the `sdkFactory` is pure (no side effects), and the SDK instance includes a `init` method to run initialization side effects
-  lazyInit?: boolean,
 
   // The settings must be already validated
   settings: ISettings,

package/src/services/decorateHeaders.ts

@@ -31,3 +31,8 @@ export function decorateHeaders(settings: ISettings, headers: Record<string, str
   }
   return headers;
 }
+
+export function removeNonISO88591(input: string) {
+  // eslint-disable-next-line no-control-regex
+  return input.replace(/[^\x00-\xFF]/g, '');
+}

package/src/services/splitApi.ts

@@ -4,7 +4,7 @@ import { splitHttpClientFactory } from './splitHttpClient';
 import { ISplitApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
@@ -22,7 +22,7 @@ function userKeyToQueryParam(userKey: string) {
  */
 export function splitApiFactory(
   settings: ISettings,
-  platform: Pick<IPlatform, 'getOptions' | 'getFetch'>,
+  platform: IPlatform,
   telemetryTracker: ITelemetryTracker
 ): ISplitApi {
 
@@ -67,15 +67,15 @@ export function splitApiFactory(
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 
-    fetchMemberships(userMatchingKey: string, noCache?: boolean, till?: number) {
+    fetchMySegments(userMatchingKey: string, noCache?: boolean) {
       /**
        * URI encoding of user keys in order to:
-       *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
-       *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
+       *  - avoid 400 responses (due to URI malformed). E.g.: '/api/mySegments/%'
+       *  - avoid 404 responses. E.g.: '/api/mySegments/foo/bar'
        *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
        */
-      const url = `${urls.sdk}/memberships/${encodeURIComponent(userMatchingKey)}${till ? '?till=' + till : ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
+      const url = `${urls.sdk}/mySegments/${encodeURIComponent(userMatchingKey)}`;
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
     },
 
     /**

package/src/services/splitHttpClient.ts

@@ -3,8 +3,10 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';
 import { ISettings } from '../types';
 import { IPlatform } from '../sdkFactory/types';
-import { decorateHeaders } from './decorateHeaders';
+import { decorateHeaders, removeNonISO88591 } from './decorateHeaders';
+import { timeout } from '../utils/promise/timeout';
 
+const PENDING_FETCH_ERROR_TIMEOUT = 100;
 const messageNoFetch = 'Global fetch API is not available.';
 
 /**
@@ -13,7 +15,7 @@ const messageNoFetch = 'Global fetch API is not available.';
  * @param settings SDK settings, used to access authorizationKey, logger instance and metadata (SDK version, ip and hostname) to set additional headers
  * @param platform object containing environment-specific dependencies
  */
-export function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: Pick<IPlatform, 'getOptions' | 'getFetch'>): ISplitHttpClient {
+export function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: IPlatform): ISplitHttpClient {
 
   const { log, core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
   const options = getOptions && getOptions(settings);
@@ -30,7 +32,7 @@ export function splitHttpClientFactory(settings: ISettings, { getOptions, getFet
   };
 
   if (ip) commonHeaders['SplitSDKMachineIP'] = ip;
-  if (hostname) commonHeaders['SplitSDKMachineName'] = hostname;
+  if (hostname) commonHeaders['SplitSDKMachineName'] = removeNonISO88591(hostname);
 
   return function httpClient(url: string, reqOpts: IRequestOptions = {}, latencyTracker: (error?: NetworkError) => void = () => { }, logErrorsAsInfo: boolean = false): Promise<IResponse> {
 
@@ -45,7 +47,8 @@ export function splitHttpClientFactory(settings: ISettings, { getOptions, getFet
       // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
       .then(response => {
         if (!response.ok) {
-          return response.text().then(message => Promise.reject({ response, message }));
+          // `text()` promise might not settle in some fetch implementations and cases (e.g. no content)
+          return timeout(PENDING_FETCH_ERROR_TIMEOUT, response.text()).then(message => Promise.reject({ response, message }), () => Promise.reject({ response }));
         }
         latencyTracker();
         return response;

package/src/services/types.ts

@@ -39,7 +39,7 @@ export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: numbe
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
-export type IFetchMemberships = (userMatchingKey: string, noCache?: boolean, till?: number) => Promise<IResponse>
+export type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
@@ -61,7 +61,7 @@ export interface ISplitApi {
 	fetchAuth: IFetchAuth
 	fetchSplitChanges: IFetchSplitChanges
 	fetchSegmentChanges: IFetchSegmentChanges
-	fetchMemberships: IFetchMemberships
+	fetchMySegments: IFetchMySegments
 	postEventsBulk: IPostEventsBulk
 	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
 	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs

package/src/storages/AbstractSegmentsCacheSync.ts

@@ -0,0 +1,68 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-unused-vars */
+import { ISegmentsCacheSync } from './types';
+
+/**
+ * This class provides a skeletal implementation of the ISegmentsCacheSync interface
+ * to minimize the effort required to implement this interface.
+ */
+export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
+  /**
+   * For server-side synchronizer: add `segmentKeys` list of keys to `name` segment.
+   * For client-side synchronizer: add `name` segment to the cache. `segmentKeys` is undefined.
+   */
+  abstract addToSegment(name: string, segmentKeys?: string[]): boolean
+
+  /**
+   * For server-side synchronizer: remove `segmentKeys` list of keys from `name` segment.
+   * For client-side synchronizer: remove `name` segment from the cache. `segmentKeys` is undefined.
+   */
+  abstract removeFromSegment(name: string, segmentKeys?: string[]): boolean
+
+  /**
+   * For server-side synchronizer: check if `key` is in `name` segment.
+   * For client-side synchronizer: check if `name` segment is in the cache. `key` is undefined.
+   */
+  abstract isInSegment(name: string, key?: string): boolean
+
+  /**
+   * clear the cache.
+   */
+  abstract clear(): void
+
+  /**
+   * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
+   * For client-side synchronizer: the method is not used.
+   */
+  registerSegments(names: string[]): boolean { return false; }
+
+  /**
+   * For server-side synchronizer: get the list of segments to fetch changes.
+   * Also used for the `seC` (segment count) telemetry stat.
+   */
+  abstract getRegisteredSegments(): string[]
+
+  /**
+   * Only used for the `skC`(segment keys count) telemetry stat: 1 for client-side, and total count of keys in server-side.
+   * @TODO for client-side it should be the number of clients, but it requires a refactor of MySegments caches to simplify the code.
+   */
+  abstract getKeysCount(): number
+
+  /**
+   * For server-side synchronizer: set the change number of `name` segment.
+   * For client-side synchronizer: the method is not used.
+   */
+  setChangeNumber(name: string, changeNumber: number): boolean { return true; }
+
+  /**
+   * For server-side synchronizer: get the change number of `name` segment.
+   * For client-side synchronizer: the method is not used.
+   */
+  getChangeNumber(name: string): number | undefined { return -1; }
+
+  /**
+   * For server-side synchronizer: the method is not used.
+   * For client-side synchronizer: reset the cache with the given list of segments.
+   */
+  resetSegments(names: string[]): boolean { return true; }
+}

package/src/storages/AbstractSplitsCacheSync.ts

@@ -2,7 +2,7 @@ import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ISet } from '../utils/lang/sets';
-import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
+import { IN_SEGMENT } from '../utils/constants';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
@@ -32,7 +32,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return splits;
   }
 
-  abstract setChangeNumber(changeNumber: number): boolean | void
+  abstract setChangeNumber(changeNumber: number): boolean
 
   abstract getChangeNumber(): number
 
@@ -94,8 +94,7 @@ export function usesSegments(split: ISplit) {
     const matchers = conditions[i].matcherGroup.matchers;
 
     for (let j = 0; j < matchers.length; j++) {
-      const matcher = matchers[j].matcherType;
-      if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT) return true;
+      if (matchers[j].matcherType === IN_SEGMENT) return true;
     }
   }