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

package/src/sdkClient/client.ts

@@ -4,7 +4,7 @@ import { getMatching, getBucketing } from '../utils/key';
 import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
 import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
 import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL } from '../utils/constants';
+import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
@@ -13,16 +13,19 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Creator of base client with getTreatments and track methods.
  */
-// @TODO missing time tracking to collect telemetry
 export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker } = params;
+  const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker } = params;
   const { log, mode } = settings;
 
   function getTreatment(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {
+    const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
+
     const wrapUp = (evaluationResult: IEvaluationResult) => {
       const queue: ImpressionDTO[] = [];
       const treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`, queue);
       impressionsTracker.track(queue, attributes);
+
+      stopTelemetryTracker(queue[0] && queue[0].label);
       return treatment;
     };
 
@@ -36,6 +39,8 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   }
 
   function getTreatments(key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false) {
+    const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
+
     const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
       const queue: ImpressionDTO[] = [];
       const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
@@ -43,6 +48,8 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
         treatments[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`, queue);
       });
       impressionsTracker.track(queue, attributes);
+
+      stopTelemetryTracker(queue[0] && queue[0].label);
       return treatments;
     };
 
@@ -101,6 +108,8 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   }
 
   function track(key: SplitIO.SplitKey, trafficTypeName: string, eventTypeId: string, value?: number, properties?: SplitIO.Properties, size = 1024) {
+    const stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
+
     const matchingKey = getMatching(key);
     const timestamp = Date.now();
     const eventData: SplitIO.EventData = {
@@ -115,7 +124,17 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
     validateTrafficTypeExistance(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
 
-    return eventTracker.track(eventData, size);
+    const result = eventTracker.track(eventData, size);
+
+    if (thenable(result)) {
+      return result.then((result) => {
+        stopTelemetryTracker();
+        return result;
+      });
+    } else {
+      stopTelemetryTracker();
+      return result;
+    }
   }
 
   return {

package/src/sdkClient/sdkClient.ts

@@ -9,7 +9,7 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager, syncManager, storage, signalListener, settings } = params;
+  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker } = params;
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -25,6 +25,9 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
     // Sdk destroy
     {
       destroy() {
+        // record stat before flushing data
+        if (!isSharedClient) telemetryTracker.sessionLength();
+
         // Stop background jobs
         syncManager && syncManager.stop();
         const flush = syncManager ? syncManager.flush() : Promise.resolve();

package/src/sdkFactory/index.ts

@@ -1,10 +1,10 @@
-import { ISdkFactoryParams } from './types';
+import { ISdkFactoryContext, ISdkFactoryContextSync, ISdkFactoryParams } from './types';
 import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
-import { IStorageFactoryParams, IStorageSync } from '../storages/types';
+import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
+import { IStorageFactoryParams } from '../storages/types';
 import { SplitIO } from '../types';
-import { ISplitApi } from '../services/types';
 import { getMatching } from '../utils/key';
 import { shouldBeOptimized } from '../trackers/impressionObserver/utils';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
@@ -24,13 +24,14 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory } = params;
   const log = settings.log;
 
-  // @TODO handle non-recoverable errors: not start sync, mark the SDK as destroyed, etc.
+  // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
+  // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
+
   // 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);
 
-  // @TODO handle non-recoverable error, such as, `fetch` api not available, invalid API Key, etc.
   const sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
-  const readinessManager = sdkReadinessManager.readinessManager;
+  const readiness = sdkReadinessManager.readinessManager;
 
   // @TODO consider passing the settings object, so that each storage access only what it needs
   const storageFactoryParams: IStorageFactoryParams = {
@@ -49,8 +50,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     // or partial consumer mode, where it only has submitters, and therefore it doesn't emit readiness events.
     onReadyCb: (error) => {
       if (error) return; // Don't emit SDK_READY if storage failed to connect. Error message is logged by wrapperAdapter
-      readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
-      readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
+      readiness.splits.emit(SDK_SPLITS_ARRIVED);
+      readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
     metadata: metadataBuilder(settings),
     log
@@ -59,29 +60,26 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const storage = storageFactory(storageFactoryParams);
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
-  // splitApi is used by SyncManager and Browser signal listener
-  const splitApi = splitApiFactory && splitApiFactory(settings, platform);
-
-  const syncManager = syncManagerFactory && syncManagerFactory({
-    settings,
-    splitApi: splitApi as ISplitApi,
-    storage: storage as IStorageSync,
-    readiness: sdkReadinessManager.readinessManager,
-    platform
-  });
-
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage });
 
   // trackers
   const observer = impressionsObserverFactory && impressionsObserverFactory();
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts);
-  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
+  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
+  const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
+
+  // splitApi is used by SyncManager and Browser signal listener
+  const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
+
+  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, sdkReadinessManager, readiness, settings, storage, platform };
+
+  const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
+  ctx.syncManager = syncManager;
 
-  // signal listener
   const signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
+  ctx.signalListener = signalListener;
 
-  // Sdk client and manager
-  const ctx = { eventTracker, impressionsTracker, sdkReadinessManager, settings, storage, syncManager, signalListener };
+  // SDK client and manager
   const clientMethod = sdkClientMethodFactory(ctx);
   const managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
 

package/src/sdkFactory/types.ts

@@ -1,33 +1,50 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
-import { ISdkReadinessManager } from '../readiness/types';
+import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
-import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
+import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 
+/**
+ * Environment related dependencies.
+ * These getters are called a fixed number of times per factory instantiation.
+ */
+export interface IPlatform {
+  getOptions?: () => object
+  getFetch?: () => (IFetch | undefined)
+  getEventSource?: () => (IEventSourceConstructor | undefined)
+  EventEmitter: new () => IEventEmitter,
+  now?: () => number
+}
+
 export interface ISdkFactoryContext {
-  storage: IStorageSync | IStorageAsync,
+  platform: IPlatform,
   sdkReadinessManager: ISdkReadinessManager,
+  readiness: IReadinessManager,
   settings: ISettings
   impressionsTracker: IImpressionsTracker,
   eventTracker: IEventTracker,
+  telemetryTracker: ITelemetryTracker,
+  storage: IStorageSync | IStorageAsync,
   signalListener?: ISignalListener
+  splitApi?: ISplitApi
   syncManager?: ISyncManager,
 }
 
-/**
- * Environment related dependencies.
- * These getters are called a fixed number of times per factory instantiation.
- */
-export interface IPlatform {
-  getOptions?: () => object
-  getFetch?: () => (IFetch | undefined)
-  getEventSource?: () => (IEventSourceConstructor | undefined)
-  EventEmitter: new () => IEventEmitter
+export interface ISdkFactoryContextSync extends ISdkFactoryContext {
+  storage: IStorageSync,
+  splitApi: ISplitApi
+  syncManager: ISyncManager,
+}
+
+export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
+  storage: IStorageAsync,
+  splitApi: undefined,
+  syncManager: undefined
 }
 
 /**
@@ -47,12 +64,12 @@ export interface ISdkFactoryParams {
 
   // Factory of Split Api (HTTP Client Service).
   // It is not required when providing an asynchronous storage or offline SyncManager
-  splitApiFactory?: (settings: ISettings, platform: IPlatform) => ISplitApi,
+  splitApiFactory?: (settings: ISettings, platform: IPlatform, telemetryTracker: ITelemetryTracker) => ISplitApi,
 
   // SyncManager factory.
   // Not required when providing an asynchronous storage (consumer mode), but required in standalone mode to avoid SDK timeout.
   // It can create an offline or online sync manager, with or without streaming support.
-  syncManagerFactory?: (params: ISyncManagerFactoryParams) => ISyncManager,
+  syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager,
 
   // Sdk manager factory
   sdkManagerFactory: (

package/src/services/splitApi.ts

@@ -3,6 +3,8 @@ import { ISettings } from '../types';
 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, MY_SEGMENT } from '../utils/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 
@@ -18,7 +20,8 @@ function userKeyToQueryParam(userKey: string) {
  */
 export function splitApiFactory(
   settings: Pick<ISettings, 'urls' | 'sync' | 'log' | 'version' | 'runtime' | 'core'>,
-  platform: Pick<IPlatform, 'getFetch' | 'getOptions'>
+  platform: Pick<IPlatform, 'getFetch' | 'getOptions'>,
+  telemetryTracker: ITelemetryTracker
 ): ISplitApi {
 
   const urls = settings.urls;
@@ -44,17 +47,17 @@ export function splitApiFactory(
         if (queryParams) // accounting the possibility that `userKeys` and thus `queryParams` are empty
           url += '?' + queryParams;
       }
-      return splitHttpClient(url);
+      return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
     },
 
     fetchSplitChanges(since: number, noCache?: boolean) {
       const url = `${urls.sdk}/splitChanges?since=${since}${filterQueryString || ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));
     },
 
     fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean) {
       const url = `${urls.sdk}/segmentChanges/${segmentName}?since=${since}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 
     fetchMySegments(userMatchingKey: string, noCache?: boolean) {
@@ -65,7 +68,7 @@ export function splitApiFactory(
        *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
        */
       const url = `${urls.sdk}/mySegments/${encodeURIComponent(userMatchingKey)}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
     },
 
     /**
@@ -76,7 +79,7 @@ export function splitApiFactory(
      */
     postEventsBulk(body: string, headers?: Record<string, string>) {
       const url = `${urls.events}/events/bulk`;
-      return splitHttpClient(url, { method: 'POST', body, headers });
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(EVENTS));
     },
 
     /**
@@ -90,7 +93,7 @@ export function splitApiFactory(
       return splitHttpClient(url, {
         // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
         method: 'POST', body, headers: objectAssign({ SplitSDKImpressionsMode }, headers)
-      });
+      }, telemetryTracker.trackHttp(IMPRESSIONS));
     },
 
     /**
@@ -101,17 +104,17 @@ export function splitApiFactory(
      */
     postTestImpressionsCount(body: string, headers?: Record<string, string>) {
       const url = `${urls.events}/testImpressions/count`;
-      return splitHttpClient(url, { method: 'POST', body, headers });
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
     },
 
-    postMetricsCounters(body: string) {
-      const url = `${urls.events}/metrics/counters`;
-      return splitHttpClient(url, { method: 'POST', body }, true);
+    postMetricsConfig(body: string) {
+      const url = `${urls.telemetry}/v1/metrics/config`;
+      return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
     },
 
-    postMetricsTimes(body: string) {
-      const url = `${urls.events}/metrics/times`;
-      return splitHttpClient(url, { method: 'POST', body }, true);
+    postMetricsUsage(body: string) {
+      const url = `${urls.telemetry}/v1/metrics/usage`;
+      return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
     }
   };
 }

package/src/services/splitHttpClient.ts

@@ -1,4 +1,4 @@
-import { IFetch, IRequestOptions, IResponse, ISplitHttpClient } from './types';
+import { IFetch, IRequestOptions, IResponse, ISplitHttpClient, NetworkError } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';
 import { ISettings } from '../types';
@@ -31,7 +31,7 @@ export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'versio
   if (ip) headers['SplitSDKMachineIP'] = ip;
   if (hostname) headers['SplitSDKMachineName'] = hostname;
 
-  return function httpClient(url: string, reqOpts: IRequestOptions = {}, logErrorsAsInfo: boolean = false): Promise<IResponse> {
+  return function httpClient(url: string, reqOpts: IRequestOptions = {}, latencyTracker: (error?: NetworkError) => void = () => { }, logErrorsAsInfo: boolean = false): Promise<IResponse> {
 
     const request = objectAssign({
       headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,
@@ -46,6 +46,7 @@ export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'versio
         if (!response.ok) {
           return response.text().then(message => Promise.reject({ response, message }));
         }
+        latencyTracker();
         return response;
       })
       .catch(error => {
@@ -68,9 +69,11 @@ export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'versio
           log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? resp.status : 'NO_STATUS', url, msg]);
         }
 
-        const networkError: Error & { statusCode?: number } = new Error(msg);
+        const networkError: NetworkError = new Error(msg);
         // passes `undefined` as statusCode if not an HTTP error (resp === undefined)
         networkError.statusCode = resp && resp.status;
+
+        latencyTracker(networkError);
         throw networkError;
       }) : Promise.reject(new Error(messageNoFetch));
   };

package/src/services/types.ts

@@ -23,13 +23,15 @@ export type IResponse = {
 	// }
 }
 
+export type NetworkError = Error & { statusCode?: number }
+
 // Reduced version of Fetch API
 export type IFetch = (url: string, options?: IRequestOptions) => Promise<IResponse>
 
 // IFetch specialization
 export type IHealthCheckAPI = () => Promise<boolean>
 
-export type ISplitHttpClient = (url: string, options?: IRequestOptions, logErrorsAsInfo?: boolean) => Promise<IResponse>
+export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean) => Promise<IResponse>
 
 export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
 
@@ -45,9 +47,9 @@ export type IPostTestImpressionsBulk = (body: string, headers?: Record<string, s
 
 export type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export type IPostMetricsCounters = (body: string) => Promise<IResponse>
+export type IPostMetricsConfig = (body: string) => Promise<IResponse>
 
-export type IPostMetricsTimes = (body: string) => Promise<IResponse>
+export type IPostMetricsUsage = (body: string) => Promise<IResponse>
 
 export interface ISplitApi {
 	getSdkAPIHealthCheck: IHealthCheckAPI
@@ -59,8 +61,8 @@ export interface ISplitApi {
 	postEventsBulk: IPostEventsBulk
 	postTestImpressionsBulk: IPostTestImpressionsBulk
 	postTestImpressionsCount: IPostTestImpressionsCount
-	postMetricsCounters: IPostMetricsCounters
-	postMetricsTimes: IPostMetricsTimes
+	postMetricsConfig: IPostMetricsConfig
+	postMetricsUsage: IPostMetricsUsage
 }
 
 // Minimal version of EventSource API used by the SDK

package/src/storages/AbstractSegmentsCacheSync.ts

@@ -37,10 +37,15 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   registerSegments(names: string[]): boolean { return false; }
 
   /**
-   * For server-side synchronizer: get the list of segments in the cache.
-   * For client-side synchronizer: the method is not used.
+   * 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.
    */
-  getRegisteredSegments(): string[] { return []; }
+  abstract getKeysCount(): number
 
   /**
    * For server-side synchronizer: set the change number of `name` segment.

package/src/storages/KeyBuilderSS.ts

@@ -1,9 +1,14 @@
 import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
+import { Method } from '../sync/submitters/types';
 
-// NOT USED
-// const everythingAfterCount = /count\.([^/]+)$/;
-// const latencyMetricNameAndBucket = /latency\.([^/]+)\.bucket\.([0-9]+)$/;
+const methodNames: Record<Method, string> = {
+  t: 'treatment',
+  ts: 'treatments',
+  tc: 'treatmentWithConfig',
+  tcs: 'treatmentsWithConfig',
+  tr: 'track'
+};
 
 export class KeyBuilderSS extends KeyBuilder {
 
@@ -19,7 +24,7 @@ export class KeyBuilderSS extends KeyBuilder {
   }
 
   private buildVersionablePrefix() {
-    return `${this.prefix}/${this.metadata.s}/${this.metadata.i}`;
+    return `${this.metadata.s}/${this.metadata.n}/${this.metadata.i}`;
   }
 
   buildImpressionsKey() {
@@ -30,58 +35,16 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.events`;
   }
 
-  private buildLatencyKeyPrefix() {
-    return `${this.buildVersionablePrefix()}/latency`;
+  buildLatencyKey(method: Method, bucket: number) {
+    return `${this.prefix}.telemetry.latencies::${this.buildVersionablePrefix()}/${methodNames[method]}/${bucket}`;
   }
 
-  buildLatencyKey(metricName: string, bucketNumber: number | string) {
-    return `${this.buildLatencyKeyPrefix()}.${metricName}.bucket.${bucketNumber}`;
+  buildExceptionKey(method: Method) {
+    return `${this.prefix}.telemetry.exceptions::${this.buildVersionablePrefix()}/${methodNames[method]}`;
   }
 
-  buildCountKey(metricName: string) {
-    return `${this.buildVersionablePrefix()}/count.${metricName}`;
-  }
-
-  // NOT USED
-  // buildGaugeKey(metricName: string) {
-  //   return `${this.buildVersionablePrefix()}/gauge.${metricName}`;
-  // }
-
-  // NOT USED
-  // searchPatternForCountKeys() {
-  //   return `${this.buildVersionablePrefix()}/count.*`;
-  // }
-
   searchPatternForSplitKeys() {
     return `${this.buildSplitKeyPrefix()}*`;
   }
 
-  // NOT USED
-  // searchPatternForLatency() {
-  //   return `${this.buildLatencyKeyPrefix()}.*`;
-  // }
-
-  // NOT USED
-  // extractCounterName(counterKey: string) {
-  //   const m = counterKey.match(everythingAfterCount);
-  //   if (m && m.length) {
-  //     return m[1]; // everything after count
-  //   } else {
-  //     throw new Error('Invalid counter key provided');
-  //   }
-  // }
-
-  // NOT USED
-  // extractLatencyMetricNameAndBucket(latencyKey: string) {
-  //   const parts = latencyKey.match(latencyMetricNameAndBucket);
-
-  //   if (parts && parts.length > 2) {
-  //     return {
-  //       metricName: parts[1],
-  //       bucketNumber: parts[2]
-  //     };
-  //   } else {
-  //     throw new Error('Invalid counter key provided');
-  //   }
-  // }
 }

package/src/storages/findLatencyIndex.ts

@@ -1,7 +1,16 @@
 import { isNaNNumber } from '../utils/lang';
 
-// @TODO add unit tests
-export function findLatencyIndex(latency: number, min = 0, max = 23, base = 1.5): number {
-  const index = Math.min(max, Math.max(min, Math.floor(Math.log(latency) / Math.log(base))));
+const MIN = 0;
+const MAX = 22;
+const BASE = 1.5;
+
+/**
+ * Calculates buckets from latency in milliseconds
+ *
+ * @param latencyInMs
+ * @returns a bucket index from 0 to 22 inclusive
+ */
+export function findLatencyIndex(latencyInMs: number): number {
+  const index = Math.min(MAX, Math.max(MIN, Math.ceil(Math.log(latencyInMs) / Math.log(BASE))));
   return isNaNNumber(index) ? 0 : index; // index is NaN if latency is not a positive number
 }

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -72,7 +72,7 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
       if (segmentName) {
         accum.push(segmentName);
       } else {
-        // @BREAKING: This is only to clean up "old" keys. Remove this whole else code block.
+        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
         segmentName = this.keys.extractOldSegmentKey(key);
 
         if (segmentName) { // this was an old segment key, let's clean up.
@@ -121,4 +121,16 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     return isDiff;
   }
 
+  getRegisteredSegments(): string[] {
+    return Object.keys(localStorage).reduce<string[]>((accum, key) => {
+      const segmentName = this.keys.extractSegmentName(key);
+      if (segmentName) accum.push(segmentName);
+      return accum;
+    }, []);
+  }
+
+  getKeysCount() {
+    return 1;
+  }
+
 }

package/src/storages/inLocalStorage/index.ts

@@ -12,7 +12,8 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 
 export interface InLocalStorageOptions {
   prefix?: string
@@ -29,7 +30,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
 
     // Fallback to InMemoryStorage if LocalStorage API is not available
     if (!isLocalStorageAvailable()) {
-      params.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Fallbacking into default MEMORY storage');
+      params.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
       return InMemoryStorageCSFactory(params);
     }
 
@@ -43,6 +44,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       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,
 
       destroy() {
         this.splits = new SplitsCacheInMemory();
@@ -62,6 +64,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
           impressions: this.impressions,
           impressionCounts: this.impressionCounts,
           events: this.events,
+          telemetry: this.telemetry,
 
           destroy() {
             this.splits = new SplitsCacheInMemory();

package/src/storages/inMemory/InMemoryStorage.ts

@@ -4,7 +4,8 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { STORAGE_MEMORY } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
+import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 
 /**
  * InMemory storage factory for standalone server-side SplitFactory
@@ -19,6 +20,7 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
     impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
     impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(params.eventsQueueSize),
+    telemetry: params.mode !== LOCALHOST_MODE ? new TelemetryCacheInMemory() : undefined, // Always track telemetry in standalone mode on server-side
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {