@splitsoftware/splitio-commons 1.6.2-rc.12 → 1.6.2-rc.14

package/src/listeners/browser.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-undef */
 // @TODO eventually migrate to JS-Browser-SDK package.
 import { ISignalListener } from './types';
-import { IRecorderCacheProducerSync, IStorageSync } from '../storages/types';
+import { IRecorderCacheSync, IStorageSync } from '../storages/types';
 import { fromImpressionsCollector } from '../sync/submitters/impressionsSubmitter';
 import { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSubmitter';
 import { IResponse, ISplitApi } from '../services/types';
@@ -12,7 +12,6 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
 import { isConsentGranted } from '../consent';
-import { telemetryCacheStatsAdapter } from '../sync/submitters/telemetrySubmitter';
 
 const VISIBILITYCHANGE_EVENT = 'visibilitychange';
 const PAGEHIDE_EVENT = 'pagehide';
@@ -84,27 +83,25 @@ export class BrowserSignalListener implements ISignalListener {
    */
   flushData() {
     if (!this.syncManager) return; // In consumer mode there is not sync manager and data to flush
+    const { events, telemetry } = this.settings.urls;
 
     // Flush impressions & events data if there is user consent
     if (isConsentGranted(this.settings)) {
-      const eventsUrl = this.settings.urls.events;
       const sim = this.settings.sync.impressionsMode;
       const extraMetadata = {
         // sim stands for Sync/Split Impressions Mode
         sim: sim === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : NONE
       };
 
-      this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
-      this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
-      if (this.storage.impressionCounts) this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
+      this._flushData(events + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
+      this._flushData(events + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
+      if (this.storage.impressionCounts) this._flushData(events + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
+      // @ts-ignore
+      if (this.storage.uniqueKeys) this._flushData(telemetry + '/v1/keys/cs/beacon', this.storage.uniqueKeys, this.serviceApi.postUniqueKeysBulkCs);
     }
 
     // Flush telemetry data
-    if (this.storage.telemetry) {
-      const telemetryUrl = this.settings.urls.telemetry;
-      const telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
-      this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
-    }
+    if (this.storage.telemetry) this._flushData(telemetry + '/v1/metrics/usage/beacon', this.storage.telemetry, this.serviceApi.postMetricsUsage);
   }
 
   flushDataIfHidden() {
@@ -112,14 +109,13 @@ export class BrowserSignalListener implements ISignalListener {
     if (document.visibilityState === 'hidden') this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden
   }
 
-  private _flushData<T>(url: string, cache: IRecorderCacheProducerSync<T>, postService: (body: string) => Promise<IResponse>, fromCacheToPayload?: (cacheData: T) => any, extraMetadata?: {}) {
+  private _flushData<T>(url: string, cache: IRecorderCacheSync<T>, postService: (body: string) => Promise<IResponse>, fromCacheToPayload?: (cacheData: T) => any, extraMetadata?: {}) {
     // if there is data in cache, send it to backend
     if (!cache.isEmpty()) {
       const dataPayload = fromCacheToPayload ? fromCacheToPayload(cache.pop()) : cache.pop();
       if (!this._sendBeacon(url, dataPayload, extraMetadata)) {
         postService(JSON.stringify(dataPayload)).catch(() => { }); // no-op just to catch a possible exception
       }
-      cache.clear();
     }
   }
 

package/src/sdkClient/sdkClient.ts

@@ -39,7 +39,7 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
 
           // Release the API Key if it is the main client
           if (!isSharedClient) releaseApiKey(settings.core.authorizationKey);
-          
+
           if (uniqueKeysTracker) uniqueKeysTracker.stop();
 
           // Cleanup storage

package/src/sdkFactory/index.ts

@@ -3,14 +3,10 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { IStorageFactoryParams } from '../storages/types';
 import { SplitIO } from '../types';
-import { getMatching } from '../utils/key';
-import { shouldBeOptimized } from '../trackers/impressionObserver/utils';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { metadataBuilder } from '../storages/metadataBuilder';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
@@ -28,7 +24,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
     filterAdapterFactory } = params;
-  const log = settings.log;
+  const { log, sync: { impressionsMode } } = settings;
 
   // @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.
@@ -39,42 +35,24 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
   const readiness = sdkReadinessManager.readinessManager;
 
-  // @TODO consider passing the settings object, so that each storage access only what it needs
-  const storageFactoryParams: IStorageFactoryParams = {
-    impressionsQueueSize: settings.scheduler.impressionsQueueSize,
-    eventsQueueSize: settings.scheduler.eventsQueueSize,
-    optimize: shouldBeOptimized(settings),
-
-    // ATM, only used by InLocalStorage
-    matchingKey: getMatching(settings.core.key),
-    splitFiltersValidation: settings.sync.__splitFiltersValidation,
-
-    // ATM, only used by PluggableStorage
-    mode: settings.mode,
-    impressionsMode: settings.sync.impressionsMode,
-
-    // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined,
-    // or partial consumer mode, where it only has submitters, and therefore it doesn't emit readiness events.
+  const storage = storageFactory({
+    settings,
     onReadyCb: (error) => {
       if (error) return; // Don't emit SDK_READY if storage failed to connect. Error message is logged by wrapperAdapter
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
-    metadata: metadataBuilder(settings),
-    log
-  };
-
-  const storage = storageFactory(storageFactoryParams);
+  });
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
   const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
+  const uniqueKeysTracker = impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
 
   let strategy;
-  switch (storageFactoryParams.impressionsMode) {
+  switch (impressionsMode) {
     case OPTIMIZED:
       strategy = strategyOptimizedFactory(observer, storage.impressionCounts!);
       break;
@@ -120,7 +98,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     },
 
     // Logger wrapper API
-    Logger: createLoggerAPI(settings.log),
+    Logger: createLoggerAPI(log),
 
     settings,
   }, extraProps && extraProps(ctx));

package/src/sdkFactory/types.ts

@@ -97,9 +97,9 @@ export interface ISdkFactoryParams {
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
   sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
 
-  // Impression observer factory. If provided, will be used for impressions dedupe
+  // Impression observer factory.
   impressionsObserverFactory: () => IImpressionObserver
-  
+
   filterAdapterFactory?: () => IFilterAdapter
 
   // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.

package/src/services/splitApi.ts

@@ -106,7 +106,7 @@ export function splitApiFactory(
       const url = `${urls.events}/testImpressions/count`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
     },
-    
+
     /**
      * Post unique keys for client side.
      *
@@ -117,7 +117,7 @@ export function splitApiFactory(
       const url = `${urls.telemetry}/v1/keys/cs`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
     },
-    
+
     /**
      * Post unique keys for server side.
      *

package/src/storages/KeyBuilderSS.ts

@@ -1,9 +1,8 @@
 import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
-import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
 
-const METHOD_NAMES: Record<Method, string> = {
+export const METHOD_NAMES: Record<Method, string> = {
   t: 'treatment',
   ts: 'treatments',
   tc: 'treatmentWithConfig',
@@ -37,7 +36,7 @@ export class KeyBuilderSS extends KeyBuilder {
   buildImpressionsCountKey() {
     return `${this.prefix}.impressions.count`;
   }
-  
+
   buildUniqueKeysKey() {
     return `${this.prefix}.uniquekeys`;
   }
@@ -65,44 +64,3 @@ export class KeyBuilderSS extends KeyBuilder {
   }
 
 }
-
-// Used by consumer methods of TelemetryCacheInRedis and TelemetryCachePluggable
-
-const REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce((acc, key) => {
-  acc[METHOD_NAMES[key as Method]] = key as Method;
-  return acc;
-}, {} as Record<string, Method>);
-
-
-export function parseMetadata(field: string): [metadata: string] | string {
-  const parts = field.split('/');
-  if (parts.length !== 3) return `invalid subsection count. Expected 3, got: ${parts.length}`;
-
-  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */] = parts;
-  return [JSON.stringify({ s, n, i })];
-}
-
-export function parseExceptionField(field: string): [metadata: string, method: Method] | string {
-  const parts = field.split('/');
-  if (parts.length !== 4) return `invalid subsection count. Expected 4, got: ${parts.length}`;
-
-  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m] = parts;
-  const method = REVERSE_METHOD_NAMES[m];
-  if (!method) return `unknown method '${m}'`;
-
-  return [JSON.stringify({ s, n, i }), method];
-}
-
-export function parseLatencyField(field: string): [metadata: string, method: Method, bucket: number] | string {
-  const parts = field.split('/');
-  if (parts.length !== 5) return `invalid subsection count. Expected 5, got: ${parts.length}`;
-
-  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m, b] = parts;
-  const method = REVERSE_METHOD_NAMES[m];
-  if (!method) return `unknown method '${m}'`;
-
-  const bucket = parseInt(b);
-  if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT) return `invalid bucket. Expected a number between 0 and ${MAX_LATENCY_BUCKET_COUNT - 1}, got: ${b}`;
-
-  return [JSON.stringify({ s, n, i }), method, bucket];
-}

package/src/storages/inLocalStorage/index.ts

@@ -12,9 +12,10 @@ 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 { NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
+import { getMatching } from '../../utils/key';
 
 export interface InLocalStorageOptions {
   prefix?: string
@@ -31,22 +32,26 @@ 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. Falling back to default MEMORY storage');
+      params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
       return InMemoryStorageCSFactory(params);
     }
 
-    const log = params.log;
-    const keys = new KeyBuilderCS(prefix, params.matchingKey as string);
+    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+    const matchingKey = getMatching(settings.core.key);
+    const keys = new KeyBuilderCS(prefix, matchingKey as string);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
+    const splits = new SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);
+    const segments = new MySegmentsCacheInLocal(log, keys);
+
     return {
-      splits: new SplitsCacheInLocal(log, keys, expirationTimestamp, params.splitFiltersValidation),
-      segments: new MySegmentsCacheInLocal(log, keys),
-      impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-      impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
-      events: new EventsCacheInMemory(params.eventsQueueSize),
-      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
-      uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
+      splits,
+      segments,
+      impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+      impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+      events: new EventsCacheInMemory(eventsQueueSize),
+      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+      uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
       destroy() {
         this.splits = new SplitsCacheInMemory();

package/src/storages/inMemory/AttributesCacheInMemory.ts

@@ -7,10 +7,10 @@ export class AttributesCacheInMemory {
 
   /**
    * Create or update the value for the given attribute
-   * 
+   *
    * @param {string} attributeName attribute name
    * @param {Object} attributeValue attribute value
-   * @returns {boolean} the attribute was stored 
+   * @returns {boolean} the attribute was stored
    */
   setAttribute(attributeName: string, attributeValue: Object): boolean {
     this.attributesCache[attributeName] = attributeValue;
@@ -19,7 +19,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Retrieves the value of a given attribute
-   * 
+   *
    * @param {string} attributeName attribute name
    * @returns {Object?} stored attribute value
    */
@@ -29,7 +29,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Create or update all the given attributes
-   * 
+   *
    * @param {[string, Object]} attributes attributes to create or update
    * @returns {boolean} attributes were stored
    */
@@ -40,7 +40,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Retrieve the full attributes map
-   * 
+   *
    * @returns {Map<string, Object>} stored attributes
    */
   getAll(): Record<string, Object> {
@@ -49,7 +49,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Removes a given attribute from the map
-   * 
+   *
    * @param {string} attributeName attribute to remove
    * @returns {boolean} attribute removed
    */
@@ -63,7 +63,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Clears all attributes stored in the SDK
-   * 
+   *
    */
   clear() {
     this.attributesCache = {};

package/src/storages/inMemory/InMemoryStorage.ts

@@ -14,15 +14,19 @@ import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
+
+  const splits = new SplitsCacheInMemory();
+  const segments = new SegmentsCacheInMemory();
 
   return {
-    splits: new SplitsCacheInMemory(),
-    segments: new SegmentsCacheInMemory(),
-    impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-    impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
-    events: new EventsCacheInMemory(params.eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
-    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
+    splits,
+    segments,
+    impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+    impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+    events: new EventsCacheInMemory(eventsQueueSize),
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+    uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -14,15 +14,19 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
+
+  const splits = new SplitsCacheInMemory();
+  const segments = new MySegmentsCacheInMemory();
 
   return {
-    splits: new SplitsCacheInMemory(),
-    segments: new MySegmentsCacheInMemory(),
-    impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-    impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
-    events: new EventsCacheInMemory(params.eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
-    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
+    splits,
+    segments,
+    impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+    impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+    events: new EventsCacheInMemory(eventsQueueSize),
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+    uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -1,7 +1,7 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
-import { LOCALHOST_MODE } from '../../utils/constants';
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload } from '../../sync/submitters/types';
+import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
 import { findLatencyIndex } from '../findLatencyIndex';
-import { IStorageFactoryParams, ITelemetryCacheSync } from '../types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 
 const MAX_STREAMING_EVENTS = 20;
 const MAX_TAGS = 10;
@@ -19,12 +19,48 @@ const ACCEPTANCE_RANGE = 0.001;
  * Record telemetry if mode is not localhost.
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export function shouldRecordTelemetry(params: IStorageFactoryParams) {
-  return params.mode !== LOCALHOST_MODE && (params.matchingKey === undefined || Math.random() <= ACCEPTANCE_RANGE);
+export function shouldRecordTelemetry({ settings }: IStorageFactoryParams) {
+  return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 
 export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
+  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync) { }
+
+  // isEmpty flag
+  private e = true;
+
+  isEmpty() { return this.e; }
+
+  clear() { /* no-op */ }
+
+  pop(): TelemetryUsageStatsPayload {
+    this.e = true;
+
+    return {
+      lS: this.getLastSynchronization(),
+      mL: this.popLatencies(),
+      mE: this.popExceptions(),
+      hE: this.popHttpErrors(),
+      hL: this.popHttpLatencies(),
+      tR: this.popTokenRefreshes(),
+      aR: this.popAuthRejections(),
+      iQ: this.getImpressionStats(QUEUED),
+      iDe: this.getImpressionStats(DEDUPED),
+      iDr: this.getImpressionStats(DROPPED),
+      spC: this.splits && this.splits.getSplitNames().length,
+      seC: this.segments && this.segments.getRegisteredSegments().length,
+      skC: this.segments && this.segments.getKeysCount(),
+      sL: this.getSessionLength(),
+      eQ: this.getEventStats(QUEUED),
+      eD: this.getEventStats(DROPPED),
+      sE: this.popStreamingEvents(),
+      t: this.popTags(),
+    };
+  }
+
+  /** Config stats */
+
   private timeUntilReady?: number;
 
   getTimeUntilReady() {
@@ -55,6 +91,8 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     this.notReadyUsage++;
   }
 
+  /** Usage stats */
+
   private impressionStats = [0, 0, 0];
 
   getImpressionStats(type: ImpressionDataType) {
@@ -63,6 +101,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordImpressionStats(type: ImpressionDataType, count: number) {
     this.impressionStats[type] += count;
+    this.e = false;
   }
 
   private eventStats = [0, 0];
@@ -73,9 +112,9 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordEventStats(type: EventDataType, count: number) {
     this.eventStats[type] += count;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private lastSync: LastSync = {};
 
   getLastSynchronization() {
@@ -84,40 +123,35 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordSuccessfulSync(resource: OperationType, timeMs: number) {
     this.lastSync[resource] = timeMs;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private httpErrors: HttpErrors = {};
 
   popHttpErrors() {
-    const result = this.httpErrors; // @ts-expect-error
+    const result = this.httpErrors;
     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]++;
-    }
+    const statusErrors = (this.httpErrors[resource] = this.httpErrors[resource] || {});
+    statusErrors[status] = (statusErrors[status] || 0) + 1;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private httpLatencies: HttpLatencies = {};
 
   popHttpLatencies() {
-    const result = this.httpLatencies; // @ts-expect-error
+    const result = this.httpLatencies;
     this.httpLatencies = {};
     return result;
   }
 
   recordHttpLatency(resource: OperationType, latencyMs: number) {
-    if (!this.httpLatencies[resource]) {
-      this.httpLatencies[resource] = newBuckets();
-    }
-    this.httpLatencies[resource][findLatencyIndex(latencyMs)]++;
+    const latencyBuckets = (this.httpLatencies[resource] = this.httpLatencies[resource] || newBuckets());
+    latencyBuckets[findLatencyIndex(latencyMs)]++;
+    this.e = false;
   }
 
   private authRejections = 0;
@@ -130,6 +164,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordAuthRejections() {
     this.authRejections++;
+    this.e = false;
   }
 
   private tokenRefreshes = 0;
@@ -142,6 +177,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordTokenRefreshes() {
     this.tokenRefreshes++;
+    this.e = false;
   }
 
   private streamingEvents: StreamingEvent[] = []
@@ -154,6 +190,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {
       this.streamingEvents.push(streamingEvent);
     }
+    this.e = false;
   }
 
   private tags: string[] = [];
@@ -166,6 +203,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     if (this.tags.length < MAX_TAGS) {
       this.tags.push(tag);
     }
+    this.e = false;
   }
 
   private sessionLength?: number;
@@ -176,39 +214,34 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordSessionLength(ms: number) {
     this.sessionLength = ms;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private exceptions: MethodExceptions = {};
 
   popExceptions() {
-    const result = this.exceptions; // @ts-expect-error
+    const result = this.exceptions;
     this.exceptions = {};
     return result;
   }
 
   recordException(method: Method) {
-    if (!this.exceptions[method]) {
-      this.exceptions[method] = 1;
-    } else {
-      this.exceptions[method]++;
-    }
+    this.exceptions[method] = (this.exceptions[method] || 0) + 1;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private latencies: MethodLatencies = {};
 
   popLatencies() {
-    const result = this.latencies; // @ts-expect-error
+    const result = this.latencies;
     this.latencies = {};
     return result;
   }
 
   recordLatency(method: Method, latencyMs: number) {
-    if (!this.latencies[method]) {
-      this.latencies[method] = newBuckets();
-    }
-    this.latencies[method][findLatencyIndex(latencyMs)]++;
+    const latencyBuckets = (this.latencies[method] = this.latencies[method] || newBuckets());
+    latencyBuckets[findLatencyIndex(latencyMs)]++;
+    this.e = false;
   }
 
 }

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -61,7 +61,7 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
 
         this.redis.del(this.key).catch(() => { /* no-op */ });
 
-        const impressionsCount: ImpressionCountsPayload = { pf: [] };
+        const pf: ImpressionCountsPayload['pf'] = [];
 
         forOwn(counts, (count, key) => {
           const nameAndTime = key.split('::');
@@ -82,14 +82,14 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
             return;
           }
 
-          impressionsCount.pf.push({
+          pf.push({
             f: nameAndTime[0],
             m: timeFrame,
             rc: rawCount,
           });
         });
 
-        return impressionsCount;
+        return { pf };
       });
   }
 }