@splitsoftware/splitio-commons 1.6.2-rc.11 → 1.6.2-rc.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.11",
+  "version": "1.6.2-rc.13",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -24,6 +24,7 @@
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
     "test": "jest",
     "test:coverage": "jest --coverage",
+    "all": "npm run check && npm run build && npm run test",
     "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",
     "publish:stable": "npm run check && npm run test && npm run build && npm publish"
   },

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/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/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/TelemetryCacheInRedis.ts

@@ -76,7 +76,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
           tr: newBuckets(),
         });
 
-        result.get(metadata)![method][bucket] = count;
+        result.get(metadata)![method]![bucket] = count;
       });
 
       return this.redis.del(this.keys.latencyPrefix).then(() => result);

package/src/storages/inRedis/index.ts

@@ -10,6 +10,7 @@ import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
 import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
+import { metadataBuilder } from '../metadataBuilder';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -24,7 +25,9 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
   const prefix = validatePrefix(options.prefix);
 
-  function InRedisStorageFactory({ log, metadata, onReadyCb, impressionsMode }: IStorageFactoryParams): IStorageAsync {
+  function InRedisStorageFactory(params: IStorageFactoryParams): IStorageAsync {
+    const { onReadyCb, settings, settings: { log, sync: { impressionsMode } } } = params;
+    const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient = new RedisAdapter(log, options.options || {});
     const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -75,7 +75,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
               tr: newBuckets(),
             });
 
-            result.get(metadata)![method][bucket] = count;
+            result.get(metadata)![method]![bucket] = count;
           }
 
           return Promise.all(latencyKeys.map((latencyKey) => this.wrapper.del(latencyKey))).then(() => result);

package/src/storages/pluggable/index.ts

@@ -18,6 +18,7 @@ import { ImpressionCountsCachePluggable } from './ImpressionCountsCachePluggable
 import { UniqueKeysCachePluggable } from './UniqueKeysCachePluggable';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
+import { metadataBuilder } from '../metadataBuilder';
 
 const NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 const NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
@@ -61,7 +62,8 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
   const prefix = validatePrefix(options.prefix);
 
   function PluggableStorageFactory(params: IStorageFactoryParams): IStorageAsync {
-    const { log, metadata, onReadyCb, mode, eventsQueueSize, impressionsQueueSize, impressionsMode, matchingKey } = params;
+    const { onReadyCb, settings, settings: { log, mode, sync: { impressionsMode }, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
+    const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
 
@@ -82,7 +84,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
     const uniqueKeysCache = impressionsMode === NONE || isSyncronizer ?
       isPartialConsumer ?
-        matchingKey === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
+        settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
         new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
       undefined;
 
@@ -90,10 +92,12 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     const connectPromise = wrapper.connect().then(() => {
       onReadyCb();
 
-      // Start periodic flush of async storages
-      if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
-      if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
-      if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig && !isSyncronizer) (telemetry as ITelemetryCacheAsync).recordConfig();
+      // Start periodic flush of async storages if not running synchronizer (producer mode)
+      if (!isSyncronizer) {
+        if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
+        if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
+        if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
+      }
     }).catch((e) => {
       e = e || new Error('Error connecting wrapper');
       onReadyCb(e);
@@ -109,9 +113,9 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       telemetry,
       uniqueKeys: uniqueKeysCache,
 
-      // Disconnect the underlying storage
+      // Stop periodic flush and disconnect the underlying storage
       destroy() {
-        return Promise.all([
+        return Promise.all(isSyncronizer ? [] : [
           impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).stop && (impressionCountsCache as ImpressionCountsCachePluggable).stop(),
           uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).stop && (uniqueKeysCache as UniqueKeysCachePluggable).stop(),
         ]).then(() => wrapper.disconnect());