@splitsoftware/splitio-commons 1.6.2-rc.8 → 1.7.0

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

@@ -7,8 +7,8 @@ export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync
   private readonly maxStorage: number;
   protected onFullQueue?: () => void;
   private cacheSize = 0;
-  
-  constructor(impressionCountsCacheSize: number = DEFAULT_CACHE_SIZE) {
+
+  constructor(impressionCountsCacheSize = DEFAULT_CACHE_SIZE) {
     this.maxStorage = impressionCountsCacheSize;
   }
 

package/src/storages/inMemory/InMemoryStorage.ts

@@ -4,9 +4,9 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
-import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemory } from './uniqueKeysCacheInMemory';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
 
 /**
  * InMemory storage factory for standalone server-side SplitFactory
@@ -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: params.mode !== LOCALHOST_MODE ? new TelemetryCacheInMemory() : undefined, // Always track telemetry in standalone mode on server-side
-    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemory(params.uniqueKeysCacheSize) : 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

@@ -4,9 +4,9 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageSync, IStorageFactoryParams } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from './uniqueKeysCacheInMemoryCS';
+import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -14,16 +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: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
-    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS(params.uniqueKeysCacheSize) : 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,26 +1,66 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
+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 { ITelemetryCacheSync } from '../types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 
 const MAX_STREAMING_EVENTS = 20;
 const MAX_TAGS = 10;
+export const MAX_LATENCY_BUCKET_COUNT = 23;
 
-function newBuckets() {
-  // MAX_LATENCY_BUCKET_COUNT (length) is 23;
+export function newBuckets() {
+  // MAX_LATENCY_BUCKET_COUNT (length) is 23
+  // Not using Array.fill for old browsers compatibility
   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
+ * Record telemetry if mode is not localhost.
+ * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export function shouldRecordTelemetry() {
-  return 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() {
@@ -51,6 +91,8 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     this.notReadyUsage++;
   }
 
+  /** Usage stats */
+
   private impressionStats = [0, 0, 0];
 
   getImpressionStats(type: ImpressionDataType) {
@@ -59,6 +101,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordImpressionStats(type: ImpressionDataType, count: number) {
     this.impressionStats[type] += count;
+    this.e = false;
   }
 
   private eventStats = [0, 0];
@@ -69,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() {
@@ -80,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;
@@ -126,6 +164,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordAuthRejections() {
     this.authRejections++;
+    this.e = false;
   }
 
   private tokenRefreshes = 0;
@@ -138,6 +177,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordTokenRefreshes() {
     this.tokenRefreshes++;
+    this.e = false;
   }
 
   private streamingEvents: StreamingEvent[] = []
@@ -150,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[] = [];
@@ -162,6 +203,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     if (this.tags.length < MAX_TAGS) {
       this.tags.push(tag);
     }
+    this.e = false;
   }
 
   private sessionLength?: number;
@@ -172,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/inMemory/{uniqueKeysCacheInMemory.ts → UniqueKeysCacheInMemory.ts}

@@ -3,14 +3,33 @@ import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 
+/**
+ * Converts `uniqueKeys` data from cache into request payload for SS.
+ */
+export function fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
+  const payload = [];
+  const featureNames = Object.keys(uniqueKeys);
+  for (let i = 0; i < featureNames.length; i++) {
+    const featureName = featureNames[i];
+    const userKeys = setToArray(uniqueKeys[featureName]);
+    const uniqueKeysPayload = {
+      f: featureName,
+      ks: userKeys
+    };
+
+    payload.push(uniqueKeysPayload);
+  }
+  return { keys: payload };
+}
+
 export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 
   protected onFullQueue?: () => void;
   private readonly maxStorage: number;
   private uniqueTrackerSize = 0;
-  protected uniqueKeysTracker: { [keys: string]: ISet<string> };
+  protected uniqueKeysTracker: { [featureName: string]: ISet<string> };
 
-  constructor(uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE) {
+  constructor(uniqueKeysQueueSize = DEFAULT_CACHE_SIZE) {
     this.maxStorage = uniqueKeysQueueSize;
     this.uniqueKeysTracker = {};
   }
@@ -20,15 +39,13 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
   }
 
   /**
-   * Store unique keys in sequential order
-   * key: string = feature name.
-   * value: Set<string> = set of unique keys. 
+   * Store unique keys per feature.
    */
-  track(key: string, featureName: string) {
+  track(userKey: string, featureName: string) {
     if (!this.uniqueKeysTracker[featureName]) this.uniqueKeysTracker[featureName] = new _Set();
     const tracker = this.uniqueKeysTracker[featureName];
-    if (!tracker.has(key)) {
-      tracker.add(key);
+    if (!tracker.has(userKey)) {
+      tracker.add(userKey);
       this.uniqueTrackerSize++;
     }
     if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
@@ -50,7 +67,7 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
   pop() {
     const data = this.uniqueKeysTracker;
     this.uniqueKeysTracker = {};
-    return this.fromUniqueKeysCollector(data);
+    return fromUniqueKeysCollector(data);
   }
 
   /**
@@ -59,24 +76,5 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
   isEmpty() {
     return Object.keys(this.uniqueKeysTracker).length === 0;
   }
-  
-  /**
-   * Converts `uniqueKeys` data from cache into request payload for SS.
-   */
-  private fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
-    const payload = [];
-    const featureNames = Object.keys(uniqueKeys);
-    for (let i = 0; i < featureNames.length; i++) {
-      const featureName = featureNames[i];
-      const featureKeys = setToArray(uniqueKeys[featureName]);
-      const uniqueKeysPayload = {
-        f: featureName,
-        ks: featureKeys
-      };
 
-      payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-  }
-  
 }

package/src/storages/inMemory/{uniqueKeysCacheInMemoryCS.ts → UniqueKeysCacheInMemoryCS.ts}

@@ -8,14 +8,14 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
   private onFullQueue?: () => void;
   private readonly maxStorage: number;
   private uniqueTrackerSize = 0;
-  private uniqueKeysTracker: { [keys: string]: ISet<string> };
+  private uniqueKeysTracker: { [userKey: string]: ISet<string> };
 
   /**
    *
    * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
    * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
    */
-  constructor(uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE) {   
+  constructor(uniqueKeysQueueSize = DEFAULT_CACHE_SIZE) {
     this.maxStorage = uniqueKeysQueueSize;
     this.uniqueKeysTracker = {};
   }
@@ -25,14 +25,12 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
   }
 
   /**
-   * Store unique keys in sequential order
-   * key: string = key.
-   * value: HashSet<string> = set of split names. 
+   * Store unique keys per feature.
    */
-  track(key: string, featureName: string) {
-    
-    if (!this.uniqueKeysTracker[key]) this.uniqueKeysTracker[key] = new _Set();
-    const tracker = this.uniqueKeysTracker[key];
+  track(userKey: string, featureName: string) {
+
+    if (!this.uniqueKeysTracker[userKey]) this.uniqueKeysTracker[userKey] = new _Set();
+    const tracker = this.uniqueKeysTracker[userKey];
     if (!tracker.has(featureName)) {
       tracker.add(featureName);
       this.uniqueTrackerSize++;
@@ -65,18 +63,18 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
   isEmpty() {
     return Object.keys(this.uniqueKeysTracker).length === 0;
   }
-  
+
   /**
    * Converts `uniqueKeys` data from cache into request payload.
    */
-  private fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadCs {
+  private fromUniqueKeysCollector(uniqueKeys: { [userKey: string]: ISet<string> }): UniqueKeysPayloadCs {
     const payload = [];
-    const featureKeys = Object.keys(uniqueKeys);
-    for (let k = 0; k < featureKeys.length; k++) {
-      const featureKey = featureKeys[k];
-      const featureNames = setToArray(uniqueKeys[featureKey]);
+    const userKeys = Object.keys(uniqueKeys);
+    for (let k = 0; k < userKeys.length; k++) {
+      const userKey = userKeys[k];
+      const featureNames = setToArray(uniqueKeys[userKey]);
       const uniqueKeysPayload = {
-        k: featureKey,
+        k: userKey,
         fs: featureNames
       };
 
@@ -84,5 +82,5 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
     }
     return { keys: payload };
   }
-  
+
 }

package/src/storages/inRedis/EventsCacheInRedis.ts

@@ -59,7 +59,7 @@ export class EventsCacheInRedis implements IEventsCacheAsync {
 
   /**
    * Pop the given number of events from the storage.
-   * The returned promise rejects if the wrapper operation fails.
+   * The returned promise rejects if the redis operation fails.
    *
    * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
    * It is the submitter responsability to handle that.

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -1,5 +1,7 @@
 import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/types';
+import { forOwn } from '../../utils/lang';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
 
@@ -10,8 +12,8 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
   private readonly redis: Redis;
   private readonly refreshRate: number;
   private intervalId: any;
-  
-  constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate: number = REFRESH_RATE) {
+
+  constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate = REFRESH_RATE) {
     super(impressionCountsCacheSize);
     this.log = log;
     this.key = key;
@@ -19,11 +21,12 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
     this.refreshRate = refreshRate;
     this.onFullQueue = () => { this.postImpressionCountsInRedis(); };
   }
-  
-  postImpressionCountsInRedis(){
+
+  private postImpressionCountsInRedis() {
     const counts = this.pop();
     const keys = Object.keys(counts);
-    if (!keys) return Promise.resolve(false);
+    if (!keys.length) return Promise.resolve(false);
+
     const pipeline = this.redis.pipeline();
     keys.forEach(key => {
       pipeline.hincrby(this.key, key, counts[key]);
@@ -37,16 +40,56 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
       })
       .catch(err => {
         this.log.error(`${LOG_PREFIX}Error in impression counts pipeline: ${err}.`);
-        return Promise.resolve(false);
+        return false;
       });
   }
-  
+
   start() {
     this.intervalId = setInterval(this.postImpressionCountsInRedis.bind(this), this.refreshRate);
   }
-  
+
   stop() {
     clearInterval(this.intervalId);
     return this.postImpressionCountsInRedis();
   }
+
+  // Async consumer API, used by synchronizer
+  getImpressionsCount(): Promise<ImpressionCountsPayload | undefined> {
+    return this.redis.hgetall(this.key)
+      .then(counts => {
+        if (!Object.keys(counts).length) return undefined;
+
+        this.redis.del(this.key).catch(() => { /* no-op */ });
+
+        const pf: ImpressionCountsPayload['pf'] = [];
+
+        forOwn(counts, (count, key) => {
+          const nameAndTime = key.split('::');
+          if (nameAndTime.length !== 2) {
+            this.log.error(`${LOG_PREFIX}Error spliting key ${key}`);
+            return;
+          }
+
+          const timeFrame = parseInt(nameAndTime[1]);
+          if (isNaN(timeFrame)) {
+            this.log.error(`${LOG_PREFIX}Error parsing time frame ${nameAndTime[1]}`);
+            return;
+          }
+
+          const rawCount = parseInt(count);
+          if (isNaN(rawCount)) {
+            this.log.error(`${LOG_PREFIX}Error parsing raw count ${count}`);
+            return;
+          }
+
+          pf.push({
+            f: nameAndTime[0],
+            m: timeFrame,
+            rc: rawCount,
+          });
+        });
+
+        return { pf };
+      });
+  }
 }