@splitsoftware/splitio-commons 1.3.1 → 1.3.2-rc.2

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -4,7 +4,8 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageSync, IStorageFactoryParams } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { STORAGE_MEMORY } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -19,6 +20,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
     impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(params.eventsQueueSize),
+    telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {
@@ -37,6 +39,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
         impressions: this.impressions,
         impressionCounts: this.impressionCounts,
         events: this.events,
+        telemetry: this.telemetry,
 
         // Set a new splits cache to clean it for the client without affecting other clients
         destroy() {

package/src/storages/inMemory/MySegmentsCacheInMemory.ts

@@ -72,4 +72,12 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     return isDiff;
   }
 
+  getRegisteredSegments() {
+    return Object.keys(this.segmentCache);
+  }
+
+  getKeysCount() {
+    return 1;
+  }
+
 }

package/src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -68,6 +68,12 @@ export class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     return Object.keys(this.segmentCache);
   }
 
+  getKeysCount() {
+    return Object.keys(this.segmentCache).reduce((acum, segmentName) => {
+      return acum + this.segmentCache[segmentName].size;
+    }, 0);
+  }
+
   setChangeNumber(name: string, changeNumber: number) {
     this.segmentChangeNumber[name] = changeNumber;
 

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -0,0 +1,210 @@
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
+import { findLatencyIndex } from '../findLatencyIndex';
+import { ITelemetryCacheSync } from '../types';
+
+const MAX_STREAMING_EVENTS = 20;
+const MAX_TAGS = 10;
+
+function newBuckets() {
+  // MAX_LATENCY_BUCKET_COUNT (length) is 23;
+  return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+}
+
+const ACCEPTANCE_RANGE = 0.001;
+
+/**
+ * Used on client-side. 0.1% of instances will track telemetry
+ */
+export function shouldRecordTelemetry() {
+  return Math.random() <= ACCEPTANCE_RANGE;
+}
+
+export class TelemetryCacheInMemory implements ITelemetryCacheSync {
+
+  private timeUntilReady?: number;
+
+  getTimeUntilReady() {
+    return this.timeUntilReady;
+  }
+
+  recordTimeUntilReady(ms: number) {
+    this.timeUntilReady = ms;
+  }
+
+  private timeUntilReadyFromCache?: number;
+
+  getTimeUntilReadyFromCache() {
+    return this.timeUntilReadyFromCache;
+  }
+
+  recordTimeUntilReadyFromCache(ms: number) {
+    this.timeUntilReadyFromCache = ms;
+  }
+
+  private notReadyUsage = 0;
+
+  getNonReadyUsage() {
+    return this.notReadyUsage;
+  }
+
+  recordNonReadyUsage() {
+    this.notReadyUsage++;
+  }
+
+  private impressionStats = [0, 0, 0];
+
+  getImpressionStats(type: ImpressionDataType) {
+    return this.impressionStats[type];
+  }
+
+  recordImpressionStats(type: ImpressionDataType, count: number) {
+    this.impressionStats[type] += count;
+  }
+
+  private eventStats = [0, 0];
+
+  getEventStats(type: EventDataType) {
+    return this.eventStats[type];
+  }
+
+  recordEventStats(type: EventDataType, count: number) {
+    this.eventStats[type] += count;
+  }
+
+  // @ts-expect-error
+  private lastSync: LastSync = {};
+
+  getLastSynchronization() {
+    return this.lastSync;
+  }
+
+  recordSuccessfulSync(resource: OperationType, timeMs: number) {
+    this.lastSync[resource] = timeMs;
+  }
+
+  // @ts-expect-error
+  private httpErrors: HttpErrors = {};
+
+  popHttpErrors() {
+    const result = this.httpErrors; // @ts-expect-error
+    this.httpErrors = {};
+    return result;
+  }
+
+  recordHttpError(resource: OperationType, status: number) {
+    if (!this.httpErrors[resource]) this.httpErrors[resource] = {};
+    if (!this.httpErrors[resource][status]) {
+      this.httpErrors[resource][status] = 1;
+    } else {
+      this.httpErrors[resource][status]++;
+    }
+  }
+
+  // @ts-expect-error
+  private httpLatencies: HttpLatencies = {};
+
+  popHttpLatencies() {
+    const result = this.httpLatencies; // @ts-expect-error
+    this.httpLatencies = {};
+    return result;
+  }
+
+  recordHttpLatency(resource: OperationType, latencyMs: number) {
+    if (!this.httpLatencies[resource]) {
+      this.httpLatencies[resource] = newBuckets();
+    }
+    this.httpLatencies[resource][findLatencyIndex(latencyMs)]++;
+  }
+
+  private authRejections = 0;
+
+  popAuthRejections() {
+    const result = this.authRejections;
+    this.authRejections = 0;
+    return result;
+  }
+
+  recordAuthRejections() {
+    this.authRejections++;
+  }
+
+  private tokenRefreshes = 0;
+
+  popTokenRefreshes() {
+    const result = this.tokenRefreshes;
+    this.tokenRefreshes = 0;
+    return result;
+  }
+
+  recordTokenRefreshes() {
+    this.tokenRefreshes++;
+  }
+
+  private streamingEvents: StreamingEvent[] = []
+
+  popStreamingEvents() {
+    return this.streamingEvents.splice(0);
+  }
+
+  recordStreamingEvents(streamingEvent: StreamingEvent) {
+    if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {
+      this.streamingEvents.push(streamingEvent);
+    }
+  }
+
+  private tags: string[] = [];
+
+  popTags() {
+    return this.tags.splice(0);
+  }
+
+  addTag(tag: string) {
+    if (this.tags.length < MAX_TAGS) {
+      this.tags.push(tag);
+    }
+  }
+
+  private sessionLength?: number;
+
+  getSessionLength() {
+    return this.sessionLength;
+  }
+
+  recordSessionLength(ms: number) {
+    this.sessionLength = ms;
+  }
+
+  // @ts-expect-error
+  private exceptions: MethodExceptions = {};
+
+  popExceptions() {
+    const result = this.exceptions; // @ts-expect-error
+    this.exceptions = {};
+    return result;
+  }
+
+  recordException(method: Method) {
+    if (!this.exceptions[method]) {
+      this.exceptions[method] = 1;
+    } else {
+      this.exceptions[method]++;
+    }
+  }
+
+  // @ts-expect-error
+  private latencies: MethodLatencies = {};
+
+  popLatencies() {
+    const result = this.latencies; // @ts-expect-error
+    this.latencies = {};
+    return result;
+  }
+
+  recordLatency(method: Method, latencyMs: number) {
+    if (!this.latencies[method]) {
+      this.latencies[method] = newBuckets();
+    }
+    this.latencies[method][findLatencyIndex(latencyMs)]++;
+  }
+
+}

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -0,0 +1,29 @@
+import { ILogger } from '../../logger/types';
+import { Method } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { ITelemetryCacheAsync } from '../types';
+import { findLatencyIndex } from '../findLatencyIndex';
+import { Redis } from 'ioredis';
+
+export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
+
+  /**
+   * Create a Telemetry cache that uses Redis as storage.
+   * @param log  Logger instance.
+   * @param keys  Key builder.
+   * @param redis  Redis client.
+   */
+  constructor(private readonly log: ILogger, private readonly keys: KeyBuilderSS, private readonly redis: Redis) { }
+
+  recordLatency(method: Method, latencyMs: number) {
+    const [key, field] = this.keys.buildLatencyKey(method, findLatencyIndex(latencyMs)).split('::');
+    return this.redis.hincrby(key, field, 1)
+      .catch(() => { /* Handle rejections for telemetry */ });
+  }
+  recordException(method: Method) {
+    const [key, field] = this.keys.buildExceptionKey(method).split('::');
+    return this.redis.hincrby(key, field, 1)
+      .catch(() => { /* Handle rejections for telemetry */ });
+  }
+
+}

package/src/storages/inRedis/index.ts

@@ -6,9 +6,8 @@ import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { LatenciesCacheInRedis } from './LatenciesCacheInRedis';
-import { CountsCacheInRedis } from './CountsCacheInRedis';
 import { STORAGE_REDIS } from '../../utils/constants';
+import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -38,8 +37,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
       events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
-      latencies: new LatenciesCacheInRedis(keys, redisClient),
-      counts: new CountsCacheInRedis(keys, redisClient),
+      telemetry: new TelemetryCacheInRedis(log, keys, redisClient),
 
       // When using REDIS we should:
       // 1- Disconnect from the storage

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -0,0 +1,26 @@
+import { ILogger } from '../../logger/types';
+import { Method } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
+import { findLatencyIndex } from '../findLatencyIndex';
+
+export class TelemetryCachePluggable implements ITelemetryCacheAsync {
+
+  /**
+   * Create a Telemetry cache that uses a storage wrapper.
+   * @param log  Logger instance.
+   * @param keys  Key builder.
+   * @param wrapper  Adapted wrapper storage.
+   */
+  constructor(private readonly log: ILogger, private readonly keys: KeyBuilderSS, private readonly wrapper: IPluggableStorageWrapper) { }
+
+  recordLatency(method: Method, latencyMs: number) {
+    return this.wrapper.incr(this.keys.buildLatencyKey(method, findLatencyIndex(latencyMs)))
+      .catch(() => { /* Handle rejections for telemetry */ });
+  }
+  recordException(method: Method) {
+    return this.wrapper.incr(this.keys.buildExceptionKey(method))
+      .catch(() => { /* Handle rejections for telemetry */ });
+  }
+
+}

package/src/storages/pluggable/index.ts

@@ -77,7 +77,8 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
       impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
       events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-      // @TODO add telemetry cache when required
+      // @TODO Not using TelemetryCachePluggable yet, because it is not supported by the Split Synchronizer
+      // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
 
       // Disconnect the underlying storage
       destroy() {

package/src/storages/types.ts

@@ -1,6 +1,6 @@
 import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
 import { ILogger } from '../logger/types';
-import { StoredEventWithMetadata, StoredImpressionWithMetadata } from '../sync/submitters/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 
 /**
@@ -262,6 +262,7 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
   isInSegment(name: string, key?: string): boolean
   registerSegments(names: string[]): boolean
   getRegisteredSegments(): string[]
+  getKeysCount(): number // only used for telemetry
   setChangeNumber(name: string, changeNumber: number): boolean
   getChangeNumber(name: string): number
   resetSegments(names: string[]): boolean // only for Sync Client-Side
@@ -331,11 +332,13 @@ export interface IRecorderCacheProducerAsync<T> {
 
 export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheProducerAsync<StoredImpressionWithMetadata[]> {
   // Consumer API method, used by impressions tracker (in standalone and consumer modes) to push data into.
+  // The result promise can reject.
   track(data: ImpressionDTO[]): Promise<void>
 }
 
 export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
   // Consumer API method, used by events tracker (in standalone and consumer modes) to push data into.
+  // The result promise cannot reject.
   track(data: SplitIO.EventData, size?: number): Promise<boolean>
 }
 
@@ -354,31 +357,86 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
 }
 
 
-/** Latencies and metric counts cache */
-// @TODO remove. They are deprecated.
+/**
+ * Telemetry storage interface for standalone and partial consumer modes.
+ * Methods are sync because data is stored in memory.
+ */
 
-export interface ILatenciesCacheSync extends IRecorderCacheProducerSync<Record<string, number[]>> {
-  track(metricName: string, latency: number): boolean
-  isEmpty(): boolean
-  clear(): void
-  state(): Record<string, number[]>
+export interface ITelemetryInitConsumerSync {
+  getTimeUntilReady(): number | undefined;
+  getTimeUntilReadyFromCache(): number | undefined;
+  getNonReadyUsage(): number;
+  // 'active factories' and 'redundant factories' are not tracked in the storage. They are derived from `usedKeysMap`
 }
 
-export interface ILatenciesCacheAsync {
-  track(metricName: string, latency: number): Promise<boolean>
+export interface ITelemetryRuntimeConsumerSync {
+  getImpressionStats(type: ImpressionDataType): number;
+  getEventStats(type: EventDataType): number;
+  getLastSynchronization(): LastSync;
+  popHttpErrors(): HttpErrors;
+  popHttpLatencies(): HttpLatencies;
+  popAuthRejections(): number;
+  popTokenRefreshes(): number;
+  popStreamingEvents(): Array<StreamingEvent>;
+  popTags(): Array<string> | undefined;
+  getSessionLength(): number | undefined;
 }
 
-export interface ICountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-  track(metricName: string): boolean
-  isEmpty(): boolean
-  clear(): void
-  state(): Record<string, number>
+export interface ITelemetryEvaluationConsumerSync {
+  popExceptions(): MethodExceptions;
+  popLatencies(): MethodLatencies;
+}
+
+export interface ITelemetryStorageConsumerSync extends ITelemetryInitConsumerSync, ITelemetryRuntimeConsumerSync, ITelemetryEvaluationConsumerSync { }
+
+export interface ITelemetryInitProducerSync {
+  recordTimeUntilReady(ms: number): void;
+  recordTimeUntilReadyFromCache(ms: number): void;
+  recordNonReadyUsage(): void;
+  // 'active factories' and 'redundant factories' are not tracked in the storage. They are derived from `usedKeysMap`
+}
+
+export interface ITelemetryRuntimeProducerSync {
+  addTag(tag: string): void;
+  recordImpressionStats(type: ImpressionDataType, count: number): void;
+  recordEventStats(type: EventDataType, count: number): void;
+  recordSuccessfulSync(resource: OperationType, timeMs: number): void;
+  recordHttpError(resource: OperationType, status: number): void;
+  recordHttpLatency(resource: OperationType, latencyMs: number): void;
+  recordAuthRejections(): void;
+  recordTokenRefreshes(): void;
+  recordStreamingEvents(streamingEvent: StreamingEvent): void;
+  recordSessionLength(ms: number): void;
 }
 
-export interface ICountsCacheAsync {
-  track(metricName: string): Promise<boolean>
+export interface ITelemetryEvaluationProducerSync {
+  recordLatency(method: Method, latencyMs: number): void;
+  recordException(method: Method): void;
 }
 
+export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync { }
+
+export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync { }
+
+/**
+ * Telemetry storage interface for consumer mode.
+ * Methods are async because data is stored in Redis or a pluggable storage.
+ */
+
+export interface ITelemetryEvaluationConsumerAsync {
+  popExceptions(): Promise<MethodExceptions>;
+  popLatencies(): Promise<MethodLatencies>;
+}
+
+export interface ITelemetryEvaluationProducerAsync {
+  recordLatency(method: Method, latencyMs: number): Promise<any>;
+  recordException(method: Method): Promise<any>;
+}
+
+// ATM it only implements the producer API, used by the SDK in consumer mode.
+// @TODO implement consumer API for JS Synchronizer.
+export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync { }
+
 /**
  * Storages
  */
@@ -388,37 +446,33 @@ export interface IStorageBase<
   TSegmentsCache extends ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase,
   TEventsCache extends IEventsCacheBase,
-  TLatenciesCache extends ILatenciesCacheSync | ILatenciesCacheAsync,
-  TCountsCache extends ICountsCacheSync | ICountsCacheAsync,
+  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync
   > {
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
   impressionCounts?: IImpressionCountsCacheSync,
   events: TEventsCache,
-  latencies?: TLatenciesCache,
-  counts?: TCountsCache,
+  telemetry?: TTelemetryCache
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
 
-export type IStorageSync = IStorageBase<
+export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
   IEventsCacheSync,
-  ILatenciesCacheSync,
-  ICountsCacheSync
->
+  ITelemetryCacheSync
+  > { }
 
-export type IStorageAsync = IStorageBase<
+export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
   IEventsCacheAsync | IEventsCacheSync,
-  ILatenciesCacheAsync,
-  ICountsCacheAsync
->
+  ITelemetryCacheAsync
+  > { }
 
 /** StorageFactory */
 
@@ -429,14 +483,12 @@ export interface IStorageFactoryParams {
   impressionsQueueSize?: number,
   eventsQueueSize?: number,
   optimize?: boolean /* whether create the `impressionCounts` cache (OPTIMIZED impression mode) or not (DEBUG impression mode) */,
+  mode: SDKMode,
 
   // ATM, only used by InLocalStorage
   matchingKey?: string, /* undefined on server-side SDKs */
   splitFiltersValidation?: ISplitFiltersValidation,
 
-  // ATM, only used by PluggableStorage
-  mode?: SDKMode,
-
   // This callback is invoked when the storage is ready to be used. Error-first callback style: if an error is passed,
   // it means that the storge fail to connect and shouldn't be used.
   // It is meant for emitting SDK_READY event in consumer mode, and for synchronizer to wait before using the storage.

package/src/sync/offline/syncManagerOffline.ts

@@ -1,9 +1,10 @@
-import { ISyncManager, ISyncManagerCS, ISyncManagerFactoryParams } from '../types';
+import { ISyncManager, ISyncManagerCS } from '../types';
 import { fromObjectSyncTaskFactory } from './syncTasks/fromObjectSyncTask';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { ISplitsParser } from './splitsParser/types';
 import { IReadinessManager } from '../../readiness/types';
 import { SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 function flush() {
   return Promise.resolve();
@@ -17,7 +18,7 @@ function flush() {
  */
 export function syncManagerOfflineFactory(
   splitsParserFactory: () => ISplitsParser
-): (params: ISyncManagerFactoryParams) => ISyncManagerCS {
+): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**
    * SyncManager factory for modular SDK
@@ -26,7 +27,7 @@ export function syncManagerOfflineFactory(
     settings,
     readiness,
     storage,
-  }: ISyncManagerFactoryParams): ISyncManagerCS {
+  }: ISdkFactoryContextSync): ISyncManagerCS {
 
     return objectAssign(
       fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings),

package/src/sync/polling/pollingManagerCS.ts

@@ -7,20 +7,20 @@ import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
-import { ISyncManagerFactoryParams } from '../types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
 export function pollingManagerCSFactory(
-  params: ISyncManagerFactoryParams
+  params: ISdkFactoryContextSync
 ): IPollingManagerCS {
 
   const { splitApi, storage, readiness, settings } = params;
   const log = settings.log;
 
-  const splitsSyncTask: ISplitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
+  const splitsSyncTask: ISplitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
 
   // Map of matching keys to their corresponding MySegmentsSyncTask.
   const mySegmentsSyncTasks: Record<string, ISegmentsSyncTask> = {};

package/src/sync/polling/pollingManagerSS.ts

@@ -3,13 +3,13 @@ import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
 import { IPollingManager, ISegmentsSyncTask, ISplitsSyncTask } from './types';
 import { thenable } from '../../utils/promise/thenable';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
-import { ISyncManagerFactoryParams } from '../types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
 export function pollingManagerSSFactory(
-  params: ISyncManagerFactoryParams
+  params: ISdkFactoryContextSync
 ): IPollingManager {
 
   const { splitApi, storage, readiness, settings } = params;

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

@@ -15,6 +15,7 @@ export function splitsSyncTaskFactory(
   storage: IStorageSync,
   readiness: IReadinessManager,
   settings: ISettings,
+  isClientSide?: boolean
 ): ISplitsSyncTask {
   return syncTaskFactory(
     settings.log,
@@ -26,6 +27,7 @@ export function splitsSyncTaskFactory(
       readiness.splits,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
+      isClientSide
     ),
     settings.scheduler.featuresRefreshRate,
     'splitChangesUpdater',

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

@@ -33,10 +33,6 @@ export function mySegmentsUpdaterFactory(
   function _promiseDecorator<T>(promise: Promise<T>) {
     if (startingUp) promise = timeout(requestTimeoutBeforeReady, promise);
     return promise;
-
-    // @TODO telemetry
-    // NOTE: We only collect metrics on startup.
-    // mySegmentsPromise = tracker.start(tracker.TaskNames.MY_SEGMENTS_FETCH, startingUp ? metricCollectors : false, mySegmentsPromise);
   }
 
   // @TODO if allowing pluggable storages, handle async execution