@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -1,268 +0,0 @@
-import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { ILogger } from '../../logger/types';
-import { LOG_PREFIX } from './constants';
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { returnDifference } from '../../utils/lang/sets';
-import type { RedisAdapter } from './RedisAdapter';
-
-/**
- * Discard errors for an answer of multiple operations.
- */
-function processPipelineAnswer(results: Array<[Error | null, string]>): string[] {
-  return results.reduce((accum: string[], errValuePair: [Error | null, string]) => {
-    if (errValuePair[0] === null) accum.push(errValuePair[1]);
-    return accum;
-  }, []);
-}
-
-/**
- * ISplitsCacheAsync implementation that stores split definitions in Redis.
- * Supported by Node.js
- */
-export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
-
-  private readonly log: ILogger;
-  private readonly redis: RedisAdapter;
-  private readonly keys: KeyBuilderSS;
-  private redisError?: string;
-  private readonly flagSetsFilter: string[];
-
-  constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter, splitFiltersValidation?: ISplitFiltersValidation) {
-    super();
-    this.log = log;
-    this.redis = redis;
-    this.keys = keys;
-    this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
-
-    // There is no need to listen for redis 'error' event, because in that case ioredis calls will be rejected and handled by redis storage adapters.
-    // But it is done just to avoid getting the ioredis message `Unhandled error event`.
-    this.redis.on('error', (e) => {
-      this.redisError = e;
-    });
-
-    this.redis.on('connect', () => {
-      this.redisError = undefined;
-    });
-  }
-
-  private _decrementCounts(split: ISplit) {
-    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-    return this.redis.decr(ttKey).then(count => {
-      if (count === 0) return this.redis.del(ttKey);
-    });
-  }
-
-  private _incrementCounts(split: ISplit) {
-    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-    return this.redis.incr(ttKey);
-  }
-
-  private _updateFlagSets(featureFlagName: string, flagSetsOfRemovedFlag?: string[], flagSetsOfAddedFlag?: string[]) {
-    const removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-
-    let addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
-    if (this.flagSetsFilter.length > 0) {
-      addToFlagSets = addToFlagSets.filter(flagSet => {
-        return this.flagSetsFilter.some(filterFlagSet => filterFlagSet === flagSet);
-      });
-    }
-
-    const items = [featureFlagName];
-
-    return Promise.all([
-      ...removeFromFlagSets.map(flagSetName => this.redis.srem(this.keys.buildFlagSetKey(flagSetName), items)),
-      ...addToFlagSets.map(flagSetName => this.redis.sadd(this.keys.buildFlagSetKey(flagSetName), items))
-    ]);
-  }
-
-  /**
-   * Add a given split.
-   * The returned promise is resolved when the operation success
-   * or rejected if it fails (e.g., redis operation fails)
-   */
-  addSplit(split: ISplit): Promise<boolean> {
-    const name = split.name;
-    const splitKey = this.keys.buildSplitKey(name);
-    return this.redis.get(splitKey).then(splitFromStorage => {
-
-      // handling parsing error
-      let parsedPreviousSplit: ISplit, stringifiedNewSplit;
-      try {
-        parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        stringifiedNewSplit = JSON.stringify(split);
-      } catch (e) {
-        throw new Error('Error parsing feature flag definition: ' + e);
-      }
-
-      return this.redis.set(splitKey, stringifiedNewSplit).then(() => {
-        // avoid unnecessary increment/decrement operations
-        if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName) return;
-
-        // update traffic type counts
-        return this._incrementCounts(split).then(() => {
-          if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
-        });
-      }).then(() => this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets));
-    }).then(() => true);
-  }
-
-  /**
-   * Remove a given split.
-   * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
-   * or rejected if it fails (e.g., redis operation fails).
-   */
-  removeSplit(name: string) {
-    return this.getSplit(name).then((split) => {
-      if (split) {
-        return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
-      }
-    }).then(() => {
-      return this.redis.del(this.keys.buildSplitKey(name)).then(status => status === 1);
-    });
-  }
-
-  /**
-   * Get split definition or null if it's not defined.
-   * Returned promise is rejected if redis operation fails.
-   */
-  getSplit(name: string): Promise<ISplit | null> {
-    if (this.redisError) {
-      this.log.error(LOG_PREFIX + this.redisError);
-
-      return Promise.reject(this.redisError);
-    }
-
-    return this.redis.get(this.keys.buildSplitKey(name))
-      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
-  }
-
-  /**
-   * Set till number.
-   * The returned promise is resolved when the operation success,
-   * or rejected if it fails.
-   */
-  setChangeNumber(changeNumber: number): Promise<boolean> {
-    return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(
-      status => status === 'OK'
-    );
-  }
-
-  /**
-   * Get till number or -1 if it's not defined.
-   * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a redis operation fails.
-   * The promise will never be rejected.
-   */
-  getChangeNumber(): Promise<number> {
-    return this.redis.get(this.keys.buildSplitsTillKey()).then((value: string | null) => {
-      const i = parseInt(value as string, 10);
-
-      return isNaNNumber(i) ? -1 : i;
-    }).catch((e) => {
-      this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
-      return -1;
-    });
-  }
-
-  /**
-   * Get list of all split definitions.
-   * The returned promise is resolved with the list of split definitions,
-   * or rejected if redis operation fails.
-   */
-  // @TODO we need to benchmark which is the maximun number of commands we could pipeline without kill redis performance.
-  getAll(): Promise<ISplit[]> {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys())
-      .then((listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec())
-      .then(processPipelineAnswer)
-      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
-        return JSON.parse(splitDefinition);
-      }));
-  }
-
-  /**
-   * Get list of split names.
-   * The returned promise is resolved with the list of split names,
-   * or rejected if redis operation fails.
-   */
-  getSplitNames(): Promise<string[]> {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(
-      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
-    );
-  }
-
-  /**
-   * Get list of feature flag names related to a given list of flag set names.
-   * The returned promise is resolved with the list of feature flag names per flag set,
-   * or rejected if the pipelined redis operation fails (e.g., timeout).
-  */
-  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
-    return this.redis.pipeline(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)])).exec()
-      .then((results) => results.map(([e, value], index) => {
-        if (e === null) return value;
-
-        this.log.error(LOG_PREFIX + `Could not read result from get members of flag set ${flagSets[index]} due to an error: ${e}`);
-      }))
-      .then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new Set(namesByFlagSet)));
-  }
-
-  /**
-   * Check traffic type existence.
-   * The returned promise is resolved with a boolean indicating whether the TT exist or not.
-   * In case of redis operation failure, the promise resolves with a true value, assuming that the TT might exist.
-   * It will never be rejected.
-   */
-  trafficTypeExists(trafficType: string): Promise<boolean> {
-    // If there is a number there should be > 0, otherwise the TT is considered as not existent.
-    return this.redis.get(this.keys.buildTrafficTypeKey(trafficType))
-      .then((ttCount: string | null | number) => {
-        if (ttCount === null) return false; // if entry doesn't exist, means that TT doesn't exist
-
-        ttCount = parseInt(ttCount as string, 10);
-        if (!isFiniteNumber(ttCount) || ttCount < 0) {
-          this.log.info(LOG_PREFIX + `Could not validate traffic type existence of ${trafficType} due to data corruption of some sorts.`);
-          return false;
-        }
-
-        return ttCount > 0;
-      })
-      .catch(e => {
-        this.log.error(LOG_PREFIX + `Could not validate traffic type existence of ${trafficType} due to an error: ${e}.`);
-        // If there is an error, bypass the validation so the event can get tracked.
-        return true;
-      });
-  }
-
-  // @TODO remove or implement. It is not being used.
-  clear() {
-    return Promise.resolve();
-  }
-
-  /**
-   * Fetches multiple splits definitions.
-   * Returned promise is rejected if redis operation fails.
-   */
-  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
-    if (this.redisError) {
-      this.log.error(LOG_PREFIX + this.redisError);
-
-      return Promise.reject(this.redisError);
-    }
-
-    const keys = names.map(name => this.keys.buildSplitKey(name));
-    return this.redis.mget(...keys)
-      .then(splitDefinitions => {
-        const splits: Record<string, ISplit | null> = {};
-        names.forEach((name, idx) => {
-          const split = splitDefinitions[idx];
-          splits[name] = split && JSON.parse(split);
-        });
-        return Promise.resolve(splits);
-      })
-      .catch(e => {
-        this.log.error(LOG_PREFIX + `Could not grab feature flags due to an error: ${e}.`);
-        return Promise.reject(e);
-      });
-  }
-
-}

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -1,144 +0,0 @@
-import { ILogger } from '../../logger/types';
-import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { ITelemetryCacheAsync } from '../types';
-import { findLatencyIndex } from '../findLatencyIndex';
-import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
-import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
-import { isNaNNumber, isString } from '../../utils/lang';
-import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
-import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
-import type { RedisAdapter } from './RedisAdapter';
-
-export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
-
-  /**
-   * Create a Telemetry cache that uses Redis as storage.
-   * @param log -  Logger instance.
-   * @param keys -  Key builder.
-   * @param redis -  Redis client.
-   */
-  constructor(private readonly log: ILogger, private readonly keys: KeyBuilderSS, private readonly redis: RedisAdapter) { }
-
-  recordLatency(method: Method, latencyMs: number) {
-    const [key, field] = this.keys.buildLatencyKey(method, findLatencyIndex(latencyMs)).split('::');
-    return this.redis.hincrby(key, field, 1)
-      .catch(() => { /* Handle rejections for telemetry */ });
-  }
-
-  recordException(method: Method) {
-    const [key, field] = this.keys.buildExceptionKey(method).split('::');
-    return this.redis.hincrby(key, field, 1)
-      .catch(() => { /* Handle rejections for telemetry */ });
-  }
-
-  recordConfig() {
-    const [key, field] = this.keys.buildInitKey().split('::');
-    const value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_REDIS));
-    return this.redis.hset(key, field, value).catch(() => { /* Handle rejections for telemetry */ });
-  }
-
-  /**
-   * Pop telemetry latencies.
-   * The returned promise rejects if redis operations fail.
-   */
-  popLatencies(): Promise<MultiMethodLatencies> {
-    return this.redis.hgetall(this.keys.latencyPrefix).then(latencies => {
-
-      const result: MultiMethodLatencies = new Map();
-
-      Object.keys(latencies).forEach(field => {
-
-        const parsedField = parseLatencyField(field);
-        if (isString(parsedField)) {
-          this.log.error(`Ignoring invalid latency field: ${field}: ${parsedField}`);
-          return;
-        }
-
-        const count = parseInt(latencies[field]);
-        if (isNaNNumber(count)) {
-          this.log.error(`Ignoring latency with invalid count: ${latencies[field]}`);
-          return;
-        }
-
-        const [metadata, method, bucket] = parsedField;
-
-        if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
-          this.log.error(`Ignoring latency with invalid bucket: ${bucket}`);
-          return;
-        }
-
-        const methodLatencies = result.get(metadata) || {};
-        methodLatencies[method] = methodLatencies[method] || newBuckets();
-        methodLatencies[method]![bucket] = count;
-        result.set(metadata, methodLatencies);
-      });
-
-      return this.redis.del(this.keys.latencyPrefix).then(() => result);
-    });
-  }
-
-  /**
-   * Pop telemetry exceptions.
-   * The returned promise rejects if redis operations fail.
-   */
-  popExceptions(): Promise<MultiMethodExceptions> {
-    return this.redis.hgetall(this.keys.exceptionPrefix).then(exceptions => {
-
-      const result: MultiMethodExceptions = new Map();
-
-      Object.keys(exceptions).forEach(field => {
-
-        const parsedField = parseExceptionField(field);
-        if (isString(parsedField)) {
-          this.log.error(`Ignoring invalid exception field: ${field}: ${parsedField}`);
-          return;
-        }
-
-        const count = parseInt(exceptions[field]);
-        if (isNaNNumber(count)) {
-          this.log.error(`Ignoring exception with invalid count: ${exceptions[field]}`);
-          return;
-        }
-
-        const [metadata, method] = parsedField;
-
-        if (!result.has(metadata)) result.set(metadata, {});
-        result.get(metadata)![method] = count;
-      });
-
-      return this.redis.del(this.keys.exceptionPrefix).then(() => result);
-    });
-  }
-
-  /**
-   * Pop telemetry configs.
-   * The returned promise rejects if redis operations fail.
-   */
-  popConfigs(): Promise<MultiConfigs> {
-    return this.redis.hgetall(this.keys.initPrefix).then(configs => {
-
-      const result: MultiConfigs = new Map();
-
-      Object.keys(configs).forEach(field => {
-
-        const parsedField = parseMetadata(field);
-        if (isString(parsedField)) {
-          this.log.error(`Ignoring invalid config field: ${field}: ${parsedField}`);
-          return;
-        }
-
-        const [metadata] = parsedField;
-
-        try {
-          const config = JSON.parse(configs[field]);
-          result.set(metadata, config);
-        } catch (e) {
-          this.log.error(`Ignoring invalid config: ${configs[field]}`);
-        }
-      });
-
-      return this.redis.del(this.keys.initPrefix).then(() => result);
-    });
-  }
-}

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -1,75 +0,0 @@
-import { IUniqueKeysCacheBase } from '../types';
-import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
-import { LOG_PREFIX } from './constants';
-import { ILogger } from '../../logger/types';
-import { UniqueKeysItemSs } from '../../sync/submitters/types';
-import type { RedisAdapter } from './RedisAdapter';
-import { setToArray } from '../../utils/lang/sets';
-
-export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
-
-  private readonly log: ILogger;
-  private readonly key: string;
-  private readonly redis: RedisAdapter;
-  private readonly refreshRate: number;
-  private intervalId: any;
-
-  constructor(log: ILogger, key: string, redis: RedisAdapter, uniqueKeysQueueSize = DEFAULT_CACHE_SIZE, refreshRate = REFRESH_RATE) {
-    super(uniqueKeysQueueSize);
-    this.log = log;
-    this.key = key;
-    this.redis = redis;
-    this.refreshRate = refreshRate;
-    this.onFullQueue = () => { this.postUniqueKeysInRedis(); };
-  }
-
-  private postUniqueKeysInRedis() {
-    const featureNames = Object.keys(this.uniqueKeysTracker);
-    if (!featureNames.length) return Promise.resolve(false);
-
-    const uniqueKeysArray = featureNames.map((featureName) => {
-      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
-      const uniqueKeysPayload = {
-        f: featureName,
-        ks: featureKeys
-      };
-      return JSON.stringify(uniqueKeysPayload);
-    });
-
-    this.clear();
-    return this.redis.rpush(this.key, uniqueKeysArray)
-      .then(data => {
-        // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
-        if (data === featureNames.length) {
-          return this.redis.expire(this.key, TTL_REFRESH);
-        }
-      })
-      .catch(err => {
-        this.log.error(`${LOG_PREFIX}Error in uniqueKeys pipeline: ${err}.`);
-        return false;
-      });
-  }
-
-
-  start() {
-    this.intervalId = setInterval(this.postUniqueKeysInRedis.bind(this), this.refreshRate);
-  }
-
-  stop() {
-    clearInterval(this.intervalId);
-    return this.postUniqueKeysInRedis();
-  }
-
-  /**
-   * Async consumer API, used by synchronizer.
-   * @param count - number of items to pop from the queue. If not provided or equal 0, all items will be popped.
-   */
-  popNRaw(count = 0): Promise<UniqueKeysItemSs[]> {
-    return this.redis.lrange(this.key, 0, count - 1).then(uniqueKeyItems => {
-      return this.redis.ltrim(this.key, uniqueKeyItems.length, -1)
-        .then(() => uniqueKeyItems.map(uniqueKeyItem => JSON.parse(uniqueKeyItem)));
-    });
-  }
-
-}

package/src/storages/inRedis/constants.ts

@@ -1,4 +0,0 @@
-export const LOG_PREFIX = 'storage:redis: ';
-export const DEFAULT_CACHE_SIZE = 30000;
-export const REFRESH_RATE = 300000; // 300000 ms = start after 5 mins
-export const TTL_REFRESH = 3600; // 1hr

package/src/storages/inRedis/index.ts

@@ -1,85 +0,0 @@
-import type { RedisAdapter } from './RedisAdapter';
-import { IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
-import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCacheInRedis } from './SplitsCacheInRedis';
-import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
-import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
-import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { STORAGE_REDIS } from '../../utils/constants';
-import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
-import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
-import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
-import { metadataBuilder } from '../utils';
-import { RBSegmentsCacheInRedis } from './RBSegmentsCacheInRedis';
-
-export interface InRedisStorageOptions {
-  prefix?: string
-  options?: Record<string, any>
-}
-
-let RD: typeof RedisAdapter | undefined;
-
-try {
-  // Using `require` to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
-  // Redis storage is not supported with .mjs files.
-  RD = require('./RedisAdapter').RedisAdapter;
-} catch (error) { /* empty */ }
-
-/**
- * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.js
- * @see {@link https://www.npmjs.com/package/ioredis}
- */
-export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsyncFactory {
-
-  const prefix = validatePrefix(options.prefix);
-
-  function InRedisStorageFactory(params: IStorageFactoryParams): IStorageAsync {
-    if (!RD) throw new Error('The SDK Redis storage is unavailable. Make sure your runtime environment supports CommonJS (`require`) so the `ioredis` dependency can be imported.');
-
-    const { onReadyFromCacheCb, onReadyCb, settings, settings: { log } } = params;
-    const metadata = metadataBuilder(settings);
-    const keys = new KeyBuilderSS(prefix, metadata);
-    const redisClient = new RD(log, options.options || {});
-    const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
-    const impressionCountsCache = new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient);
-    const uniqueKeysCache = new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient);
-
-    // RedisAdapter lets queue operations before connected
-    onReadyFromCacheCb();
-
-    // Subscription to Redis connect event in order to emit SDK_READY event on consumer mode
-    redisClient.on('connect', () => {
-      onReadyCb();
-      impressionCountsCache.start();
-      uniqueKeysCache.start();
-
-      // Synchronize config
-      telemetry.recordConfig();
-    });
-
-    return {
-      splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
-      rbSegments: new RBSegmentsCacheInRedis(log, keys, redisClient),
-      segments: new SegmentsCacheInRedis(log, keys, redisClient),
-      impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
-      impressionCounts: impressionCountsCache,
-      events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
-      telemetry,
-      uniqueKeys: uniqueKeysCache,
-
-      // When using REDIS we should:
-      // 1- Disconnect from the storage
-      destroy(): Promise<void> {
-        return Promise.all([
-          impressionCountsCache.stop(),
-          uniqueKeysCache.stop()
-        ]).then(() => { redisClient.disconnect(); });
-        // @TODO check that caches works as expected when redisClient is disconnected
-      }
-    };
-  }
-
-  InRedisStorageFactory.type = STORAGE_REDIS;
-  return InRedisStorageFactory;
-}

package/src/storages/package.json

@@ -1,3 +0,0 @@
-{
-  "sideEffects": false
-}

package/src/storages/pluggable/EventsCachePluggable.ts

@@ -1,79 +0,0 @@
-import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
-import { IMetadata } from '../../dtos/types';
-import SplitIO from '../../../types/splitio';
-import { ILogger } from '../../logger/types';
-import { LOG_PREFIX } from './constants';
-import { StoredEventWithMetadata } from '../../sync/submitters/types';
-
-export class EventsCachePluggable implements IEventsCacheAsync {
-
-  private readonly log: ILogger;
-  private readonly wrapper: IPluggableStorageWrapper;
-  private readonly key: string;
-  private readonly metadata: IMetadata;
-
-  constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata) {
-    this.log = log;
-    this.key = key;
-    this.wrapper = wrapper;
-    this.metadata = metadata;
-  }
-
-  /**
-   * Push given event to the storage.
-   * @param eventData -  Event item to push.
-   * @returns  A promise that is resolved with a boolean value indicating if the push operation succeeded or failed.
-   * Unlike `impressions::track`, The promise will never be rejected.
-   */
-  track(eventData: SplitIO.EventData): Promise<boolean> {
-    return this.wrapper.pushItems(
-      this.key,
-      [this._toJSON(eventData)]
-    )
-      // We use boolean values to signal successful queueing
-      .then(() => true)
-      .catch(e => {
-        this.log.error(`${LOG_PREFIX}Error adding event to queue: ${e}.`);
-        return false;
-      });
-  }
-
-  private _toJSON(eventData: SplitIO.EventData): string {
-    return JSON.stringify({
-      m: this.metadata,
-      e: eventData
-    } as StoredEventWithMetadata);
-  }
-
-  /**
-   * Returns a promise that resolves with the count of stored events, or 0 if there was some error.
-   * The promise will never be rejected.
-   */
-  count(): Promise<number> {
-    return this.wrapper.getItemsCount(this.key).catch(() => 0);
-  }
-
-  /**
-   * Removes the given number of events from the store. If a number is not provided, it deletes all items.
-   * The returned promise rejects if the wrapper operation fails.
-   */
-  drop(count?: number): Promise<any> {
-    if (!count) return this.wrapper.del(this.key);
-
-    return this.wrapper.popItems(this.key, count).then(() => { });
-  }
-
-  /**
-   * Pop the given number of events from the storage.
-   * The returned promise rejects if the wrapper 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.
-   */
-  popNWithMetadata(count: number): Promise<StoredEventWithMetadata[]> {
-    return this.wrapper.popItems(this.key, count).then((items) => {
-      return items.map(item => JSON.parse(item) as StoredEventWithMetadata);
-    });
-  }
-
-}