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

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -1,240 +0,0 @@
-import { __extends, __spreadArray } from "tslib";
-import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
-import { LOG_PREFIX } from './constants';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { returnDifference } from '../../utils/lang/sets';
-/**
- * Discard errors for an answer of multiple operations.
- */
-function processPipelineAnswer(results) {
-    return results.reduce(function (accum, errValuePair) {
-        if (errValuePair[0] === null)
-            accum.push(errValuePair[1]);
-        return accum;
-    }, []);
-}
-/**
- * ISplitsCacheAsync implementation that stores split definitions in Redis.
- * Supported by Node.js
- */
-var SplitsCacheInRedis = /** @class */ (function (_super) {
-    __extends(SplitsCacheInRedis, _super);
-    function SplitsCacheInRedis(log, keys, redis, splitFiltersValidation) {
-        var _this = _super.call(this) || this;
-        _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', function (e) {
-            _this.redisError = e;
-        });
-        _this.redis.on('connect', function () {
-            _this.redisError = undefined;
-        });
-        return _this;
-    }
-    SplitsCacheInRedis.prototype._decrementCounts = function (split) {
-        var _this = this;
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        return this.redis.decr(ttKey).then(function (count) {
-            if (count === 0)
-                return _this.redis.del(ttKey);
-        });
-    };
-    SplitsCacheInRedis.prototype._incrementCounts = function (split) {
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        return this.redis.incr(ttKey);
-    };
-    SplitsCacheInRedis.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
-        var _this = this;
-        var removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-        var addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
-        if (this.flagSetsFilter.length > 0) {
-            addToFlagSets = addToFlagSets.filter(function (flagSet) {
-                return _this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === flagSet; });
-            });
-        }
-        var items = [featureFlagName];
-        return Promise.all(__spreadArray(__spreadArray([], removeFromFlagSets.map(function (flagSetName) { return _this.redis.srem(_this.keys.buildFlagSetKey(flagSetName), items); }), true), addToFlagSets.map(function (flagSetName) { return _this.redis.sadd(_this.keys.buildFlagSetKey(flagSetName), items); }), true));
-    };
-    /**
-     * Add a given split.
-     * The returned promise is resolved when the operation success
-     * or rejected if it fails (e.g., redis operation fails)
-     */
-    SplitsCacheInRedis.prototype.addSplit = function (split) {
-        var _this = this;
-        var name = split.name;
-        var splitKey = this.keys.buildSplitKey(name);
-        return this.redis.get(splitKey).then(function (splitFromStorage) {
-            // handling parsing error
-            var parsedPreviousSplit, 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(function () {
-                // avoid unnecessary increment/decrement operations
-                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
-                    return;
-                // update traffic type counts
-                return _this._incrementCounts(split).then(function () {
-                    if (parsedPreviousSplit)
-                        return _this._decrementCounts(parsedPreviousSplit);
-                });
-            }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
-        }).then(function () { return 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).
-     */
-    SplitsCacheInRedis.prototype.removeSplit = function (name) {
-        var _this = this;
-        return this.getSplit(name).then(function (split) {
-            if (split) {
-                return _this._decrementCounts(split).then(function () { return _this._updateFlagSets(name, split.sets); });
-            }
-        }).then(function () {
-            return _this.redis.del(_this.keys.buildSplitKey(name)).then(function (status) { return status === 1; });
-        });
-    };
-    /**
-     * Get split definition or null if it's not defined.
-     * Returned promise is rejected if redis operation fails.
-     */
-    SplitsCacheInRedis.prototype.getSplit = function (name) {
-        if (this.redisError) {
-            this.log.error(LOG_PREFIX + this.redisError);
-            return Promise.reject(this.redisError);
-        }
-        return this.redis.get(this.keys.buildSplitKey(name))
-            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
-    };
-    /**
-     * Set till number.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails.
-     */
-    SplitsCacheInRedis.prototype.setChangeNumber = function (changeNumber) {
-        return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(function (status) { return 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.
-     */
-    SplitsCacheInRedis.prototype.getChangeNumber = function () {
-        var _this = this;
-        return this.redis.get(this.keys.buildSplitsTillKey()).then(function (value) {
-            var i = parseInt(value, 10);
-            return isNaNNumber(i) ? -1 : i;
-        }).catch(function (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.
-    SplitsCacheInRedis.prototype.getAll = function () {
-        var _this = this;
-        return this.redis.keys(this.keys.searchPatternForSplitKeys())
-            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
-            .then(processPipelineAnswer)
-            .then(function (splitDefinitions) { return splitDefinitions.map(function (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.
-     */
-    SplitsCacheInRedis.prototype.getSplitNames = function () {
-        var _this = this;
-        return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return 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).
-    */
-    SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
-        var _this = this;
-        return this.redis.pipeline(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; })).exec()
-            .then(function (results) { return results.map(function (_a, index) {
-            var e = _a[0], value = _a[1];
-            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(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return 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.
-     */
-    SplitsCacheInRedis.prototype.trafficTypeExists = function (trafficType) {
-        var _this = this;
-        // 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(function (ttCount) {
-            if (ttCount === null)
-                return false; // if entry doesn't exist, means that TT doesn't exist
-            ttCount = parseInt(ttCount, 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(function (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.
-    SplitsCacheInRedis.prototype.clear = function () {
-        return Promise.resolve();
-    };
-    /**
-     * Fetches multiple splits definitions.
-     * Returned promise is rejected if redis operation fails.
-     */
-    SplitsCacheInRedis.prototype.getSplits = function (names) {
-        var _a;
-        var _this = this;
-        if (this.redisError) {
-            this.log.error(LOG_PREFIX + this.redisError);
-            return Promise.reject(this.redisError);
-        }
-        var keys = names.map(function (name) { return _this.keys.buildSplitKey(name); });
-        return (_a = this.redis).mget.apply(_a, keys).then(function (splitDefinitions) {
-            var splits = {};
-            names.forEach(function (name, idx) {
-                var split = splitDefinitions[idx];
-                splits[name] = split && JSON.parse(split);
-            });
-            return Promise.resolve(splits);
-        })
-            .catch(function (e) {
-            _this.log.error(LOG_PREFIX + ("Could not grab feature flags due to an error: " + e + "."));
-            return Promise.reject(e);
-        });
-    };
-    return SplitsCacheInRedis;
-}(AbstractSplitsCacheAsync));
-export { SplitsCacheInRedis };

package/esm/storages/inRedis/TelemetryCacheInRedis.js

@@ -1,121 +0,0 @@
-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';
-var TelemetryCacheInRedis = /** @class */ (function () {
-    /**
-     * Create a Telemetry cache that uses Redis as storage.
-     * @param log -  Logger instance.
-     * @param keys -  Key builder.
-     * @param redis -  Redis client.
-     */
-    function TelemetryCacheInRedis(log, keys, redis) {
-        this.log = log;
-        this.keys = keys;
-        this.redis = redis;
-    }
-    TelemetryCacheInRedis.prototype.recordLatency = function (method, latencyMs) {
-        var _a = this.keys.buildLatencyKey(method, findLatencyIndex(latencyMs)).split('::'), key = _a[0], field = _a[1];
-        return this.redis.hincrby(key, field, 1)
-            .catch(function () { });
-    };
-    TelemetryCacheInRedis.prototype.recordException = function (method) {
-        var _a = this.keys.buildExceptionKey(method).split('::'), key = _a[0], field = _a[1];
-        return this.redis.hincrby(key, field, 1)
-            .catch(function () { });
-    };
-    TelemetryCacheInRedis.prototype.recordConfig = function () {
-        var _a = this.keys.buildInitKey().split('::'), key = _a[0], field = _a[1];
-        var value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_REDIS));
-        return this.redis.hset(key, field, value).catch(function () { });
-    };
-    /**
-     * Pop telemetry latencies.
-     * The returned promise rejects if redis operations fail.
-     */
-    TelemetryCacheInRedis.prototype.popLatencies = function () {
-        var _this = this;
-        return this.redis.hgetall(this.keys.latencyPrefix).then(function (latencies) {
-            var result = new Map();
-            Object.keys(latencies).forEach(function (field) {
-                var parsedField = parseLatencyField(field);
-                if (isString(parsedField)) {
-                    _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
-                    return;
-                }
-                var count = parseInt(latencies[field]);
-                if (isNaNNumber(count)) {
-                    _this.log.error("Ignoring latency with invalid count: " + latencies[field]);
-                    return;
-                }
-                var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
-                if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
-                    _this.log.error("Ignoring latency with invalid bucket: " + bucket);
-                    return;
-                }
-                var 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(function () { return result; });
-        });
-    };
-    /**
-     * Pop telemetry exceptions.
-     * The returned promise rejects if redis operations fail.
-     */
-    TelemetryCacheInRedis.prototype.popExceptions = function () {
-        var _this = this;
-        return this.redis.hgetall(this.keys.exceptionPrefix).then(function (exceptions) {
-            var result = new Map();
-            Object.keys(exceptions).forEach(function (field) {
-                var parsedField = parseExceptionField(field);
-                if (isString(parsedField)) {
-                    _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
-                    return;
-                }
-                var count = parseInt(exceptions[field]);
-                if (isNaNNumber(count)) {
-                    _this.log.error("Ignoring exception with invalid count: " + exceptions[field]);
-                    return;
-                }
-                var metadata = parsedField[0], method = parsedField[1];
-                if (!result.has(metadata))
-                    result.set(metadata, {});
-                result.get(metadata)[method] = count;
-            });
-            return _this.redis.del(_this.keys.exceptionPrefix).then(function () { return result; });
-        });
-    };
-    /**
-     * Pop telemetry configs.
-     * The returned promise rejects if redis operations fail.
-     */
-    TelemetryCacheInRedis.prototype.popConfigs = function () {
-        var _this = this;
-        return this.redis.hgetall(this.keys.initPrefix).then(function (configs) {
-            var result = new Map();
-            Object.keys(configs).forEach(function (field) {
-                var parsedField = parseMetadata(field);
-                if (isString(parsedField)) {
-                    _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
-                    return;
-                }
-                var metadata = parsedField[0];
-                try {
-                    var 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(function () { return result; });
-        });
-    };
-    return TelemetryCacheInRedis;
-}());
-export { TelemetryCacheInRedis };

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -1,66 +0,0 @@
-import { __extends } from "tslib";
-import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
-import { LOG_PREFIX } from './constants';
-import { setToArray } from '../../utils/lang/sets';
-var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
-    __extends(UniqueKeysCacheInRedis, _super);
-    function UniqueKeysCacheInRedis(log, key, redis, uniqueKeysQueueSize, refreshRate) {
-        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
-        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
-        var _this = _super.call(this, uniqueKeysQueueSize) || this;
-        _this.log = log;
-        _this.key = key;
-        _this.redis = redis;
-        _this.refreshRate = refreshRate;
-        _this.onFullQueue = function () { _this.postUniqueKeysInRedis(); };
-        return _this;
-    }
-    UniqueKeysCacheInRedis.prototype.postUniqueKeysInRedis = function () {
-        var _this = this;
-        var featureNames = Object.keys(this.uniqueKeysTracker);
-        if (!featureNames.length)
-            return Promise.resolve(false);
-        var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
-            var uniqueKeysPayload = {
-                f: featureName,
-                ks: featureKeys
-            };
-            return JSON.stringify(uniqueKeysPayload);
-        });
-        this.clear();
-        return this.redis.rpush(this.key, uniqueKeysArray)
-            .then(function (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(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
-            return false;
-        });
-    };
-    UniqueKeysCacheInRedis.prototype.start = function () {
-        this.intervalId = setInterval(this.postUniqueKeysInRedis.bind(this), this.refreshRate);
-    };
-    UniqueKeysCacheInRedis.prototype.stop = function () {
-        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.
-     */
-    UniqueKeysCacheInRedis.prototype.popNRaw = function (count) {
-        var _this = this;
-        if (count === void 0) { count = 0; }
-        return this.redis.lrange(this.key, 0, count - 1).then(function (uniqueKeyItems) {
-            return _this.redis.ltrim(_this.key, uniqueKeyItems.length, -1)
-                .then(function () { return uniqueKeyItems.map(function (uniqueKeyItem) { return JSON.parse(uniqueKeyItem); }); });
-        });
-    };
-    return UniqueKeysCacheInRedis;
-}(UniqueKeysCacheInMemory));
-export { UniqueKeysCacheInRedis };

package/esm/storages/inRedis/constants.js

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

package/esm/storages/inRedis/index.js

@@ -1,69 +0,0 @@
-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';
-var RD;
-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) {
-    if (options === void 0) { options = {}; }
-    var prefix = validatePrefix(options.prefix);
-    function InRedisStorageFactory(params) {
-        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.');
-        var onReadyFromCacheCb = params.onReadyFromCacheCb, onReadyCb = params.onReadyCb, settings = params.settings, log = params.settings.log;
-        var metadata = metadataBuilder(settings);
-        var keys = new KeyBuilderSS(prefix, metadata);
-        var redisClient = new RD(log, options.options || {});
-        var telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
-        var impressionCountsCache = new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient);
-        var 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', function () {
-            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: telemetry,
-            uniqueKeys: uniqueKeysCache,
-            // When using REDIS we should:
-            // 1- Disconnect from the storage
-            destroy: function () {
-                return Promise.all([
-                    impressionCountsCache.stop(),
-                    uniqueKeysCache.stop()
-                ]).then(function () { redisClient.disconnect(); });
-                // @TODO check that caches works as expected when redisClient is disconnected
-            }
-        };
-    }
-    InRedisStorageFactory.type = STORAGE_REDIS;
-    return InRedisStorageFactory;
-}

package/esm/storages/pluggable/EventsCachePluggable.js

@@ -1,61 +0,0 @@
-import { LOG_PREFIX } from './constants';
-var EventsCachePluggable = /** @class */ (function () {
-    function EventsCachePluggable(log, key, wrapper, metadata) {
-        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.
-     */
-    EventsCachePluggable.prototype.track = function (eventData) {
-        var _this = this;
-        return this.wrapper.pushItems(this.key, [this._toJSON(eventData)])
-            // We use boolean values to signal successful queueing
-            .then(function () { return true; })
-            .catch(function (e) {
-            _this.log.error(LOG_PREFIX + "Error adding event to queue: " + e + ".");
-            return false;
-        });
-    };
-    EventsCachePluggable.prototype._toJSON = function (eventData) {
-        return JSON.stringify({
-            m: this.metadata,
-            e: eventData
-        });
-    };
-    /**
-     * Returns a promise that resolves with the count of stored events, or 0 if there was some error.
-     * The promise will never be rejected.
-     */
-    EventsCachePluggable.prototype.count = function () {
-        return this.wrapper.getItemsCount(this.key).catch(function () { return 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.
-     */
-    EventsCachePluggable.prototype.drop = function (count) {
-        if (!count)
-            return this.wrapper.del(this.key);
-        return this.wrapper.popItems(this.key, count).then(function () { });
-    };
-    /**
-     * 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.
-     */
-    EventsCachePluggable.prototype.popNWithMetadata = function (count) {
-        return this.wrapper.popItems(this.key, count).then(function (items) {
-            return items.map(function (item) { return JSON.parse(item); });
-        });
-    };
-    return EventsCachePluggable;
-}());
-export { EventsCachePluggable };

package/esm/storages/pluggable/ImpressionCountsCachePluggable.js

@@ -1,78 +0,0 @@
-import { __extends } from "tslib";
-import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
-import { REFRESH_RATE } from '../inRedis/constants';
-import { LOG_PREFIX } from './constants';
-var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
-    __extends(ImpressionCountsCachePluggable, _super);
-    function ImpressionCountsCachePluggable(log, key, wrapper, impressionCountsCacheSize, refreshRate) {
-        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
-        var _this = _super.call(this, impressionCountsCacheSize) || this;
-        _this.log = log;
-        _this.key = key;
-        _this.wrapper = wrapper;
-        _this.refreshRate = refreshRate;
-        _this.onFullQueue = function () { _this.storeImpressionCounts(); };
-        return _this;
-    }
-    ImpressionCountsCachePluggable.prototype.storeImpressionCounts = function () {
-        var _this = this;
-        var counts = this.pop();
-        var keys = Object.keys(counts);
-        if (!keys.length)
-            return Promise.resolve(false);
-        var pipeline = keys.reduce(function (pipeline, key) {
-            return pipeline.then(function () { return _this.wrapper.incr(_this.key + "::" + key, counts[key]); });
-        }, Promise.resolve());
-        return pipeline.catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
-            return false;
-        });
-    };
-    ImpressionCountsCachePluggable.prototype.start = function () {
-        this.intervalId = setInterval(this.storeImpressionCounts.bind(this), this.refreshRate);
-    };
-    ImpressionCountsCachePluggable.prototype.stop = function () {
-        clearInterval(this.intervalId);
-        return this.storeImpressionCounts();
-    };
-    // Async consumer API, used by synchronizer
-    ImpressionCountsCachePluggable.prototype.getImpressionsCount = function () {
-        var _this = this;
-        return this.wrapper.getKeysByPrefix(this.key)
-            .then(function (keys) {
-            return keys.length ? Promise.all(keys.map(function (key) { return _this.wrapper.get(key); }))
-                .then(function (counts) {
-                keys.forEach(function (key) { return _this.wrapper.del(key).catch(function () { }); });
-                var pf = [];
-                for (var i = 0; i < keys.length; i++) {
-                    var key = keys[i];
-                    var count = counts[i];
-                    var keyFeatureNameAndTime = key.split('::');
-                    if (keyFeatureNameAndTime.length !== 3) {
-                        _this.log.error(LOG_PREFIX + "Error spliting key " + key);
-                        continue;
-                    }
-                    var timeFrame = parseInt(keyFeatureNameAndTime[2]);
-                    if (isNaN(timeFrame)) {
-                        _this.log.error(LOG_PREFIX + "Error parsing time frame " + keyFeatureNameAndTime[2]);
-                        continue;
-                    }
-                    // @ts-ignore
-                    var rawCount = parseInt(count);
-                    if (isNaN(rawCount)) {
-                        _this.log.error(LOG_PREFIX + "Error parsing raw count " + count);
-                        continue;
-                    }
-                    pf.push({
-                        f: keyFeatureNameAndTime[1],
-                        m: timeFrame,
-                        rc: rawCount,
-                    });
-                }
-                return { pf: pf };
-            }) : undefined;
-        });
-    };
-    return ImpressionCountsCachePluggable;
-}(ImpressionCountsCacheInMemory));
-export { ImpressionCountsCachePluggable };