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

package/esm/sync/submitters/telemetrySubmitter.js

@@ -1,119 +0,0 @@
-var _a, _b, _c;
-import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
-import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
-import { base } from '../../utils/settingsValidation';
-import { usedKeysMap } from '../../utils/inputValidation/apiKey';
-import { timer } from '../../utils/timeTracker/timer';
-import { objectAssign } from '../../utils/lang/objectAssign';
-var OPERATION_MODE_MAP = (_a = {},
-    _a[STANDALONE_MODE] = STANDALONE_ENUM,
-    _a[CONSUMER_MODE] = CONSUMER_ENUM,
-    _a[CONSUMER_PARTIAL_MODE] = CONSUMER_PARTIAL_ENUM,
-    _a);
-var IMPRESSIONS_MODE_MAP = (_b = {},
-    _b[OPTIMIZED] = OPTIMIZED_ENUM,
-    _b[DEBUG] = DEBUG_ENUM,
-    _b[NONE] = NONE_ENUM,
-    _b);
-var USER_CONSENT_MAP = (_c = {},
-    _c[CONSENT_UNKNOWN] = 1,
-    _c[CONSENT_GRANTED] = 2,
-    _c[CONSENT_DECLINED] = 3,
-    _c);
-function getActiveFactories() {
-    return Object.keys(usedKeysMap).length;
-}
-function getRedundantActiveFactories() {
-    return Object.keys(usedKeysMap).reduce(function (acum, sdkKey) {
-        return acum + usedKeysMap[sdkKey] - 1;
-    }, 0);
-}
-function getTelemetryFlagSetsStats(splitFiltersValidation) {
-    // Group every configured flag set in an unique array called originalSets
-    var flagSetsTotal = 0;
-    splitFiltersValidation.validFilters.forEach(function (filter) {
-        if (filter.type === 'bySet')
-            flagSetsTotal += filter.values.length;
-    });
-    var flagSetsValid = splitFiltersValidation.groupedFilters.bySet.length;
-    var flagSetsIgnored = flagSetsTotal - flagSetsValid;
-    return { flagSetsTotal: flagSetsTotal, flagSetsIgnored: flagSetsIgnored };
-}
-export function getTelemetryConfigStats(mode, storageType) {
-    return {
-        oM: OPERATION_MODE_MAP[mode],
-        st: storageType.toLowerCase(),
-        aF: getActiveFactories(),
-        rF: getRedundantActiveFactories(),
-    };
-}
-/**
- * Converts data from telemetry cache and settings into /metrics/config request payload.
- */
-export function telemetryCacheConfigAdapter(telemetry, settings) {
-    return {
-        isEmpty: function () { return false; },
-        clear: function () { },
-        pop: function () {
-            var urls = settings.urls, scheduler = settings.scheduler;
-            var isClientSide = settings.core.key !== undefined;
-            var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
-            return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
-                sE: settings.streamingEnabled,
-                rR: {
-                    sp: scheduler.featuresRefreshRate / 1000,
-                    se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
-                    ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
-                    im: scheduler.impressionsRefreshRate / 1000,
-                    ev: scheduler.eventsPushRate / 1000,
-                    te: scheduler.telemetryRefreshRate / 1000,
-                },
-                uO: {
-                    s: urls.sdk !== base.urls.sdk,
-                    e: urls.events !== base.urls.events,
-                    a: urls.auth !== base.urls.auth,
-                    st: urls.streaming !== base.urls.streaming,
-                    t: urls.telemetry !== base.urls.telemetry,
-                },
-                iQ: scheduler.impressionsQueueSize,
-                eQ: scheduler.eventsQueueSize,
-                iM: IMPRESSIONS_MODE_MAP[settings.sync.impressionsMode],
-                iL: settings.impressionListener ? true : false,
-                hP: false,
-                tR: telemetry.getTimeUntilReady(),
-                tC: telemetry.getTimeUntilReadyFromCache(),
-                nR: telemetry.getNonReadyUsage(),
-                t: telemetry.popTags(),
-                i: settings.integrations && settings.integrations.map(function (int) { return int.type; }),
-                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0,
-                fsT: flagSetsTotal,
-                fsI: flagSetsIgnored
-            });
-        }
-    };
-}
-/**
- * Submitter that periodically posts telemetry data
- */
-export function telemetrySubmitterFactory(params) {
-    var telemetry = params.storage.telemetry, now = params.platform.now;
-    if (!telemetry || !now)
-        return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
-    var startTime = timer(now);
-    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
-    readiness.gate.once(SDK_READY_FROM_CACHE, function () {
-        telemetry.recordTimeUntilReadyFromCache(startTime());
-    });
-    sdkReadinessManager.incInternalReadyCbCount();
-    readiness.gate.once(SDK_READY, function () {
-        telemetry.recordTimeUntilReady(startTime());
-        // Post config data when the SDK is ready and if the telemetry submitter was started
-        if (submitter.isRunning()) {
-            var postMetricsConfigTask = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, 'telemetry config', undefined, 0, true);
-            postMetricsConfigTask.execute();
-        }
-    });
-    return submitter;
-}

package/esm/sync/submitters/types.js

@@ -1 +0,0 @@
-export {};

package/esm/sync/submitters/uniqueKeysSubmitter.js

@@ -1,23 +0,0 @@
-import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
-import { submitterFactory } from './submitter';
-var DATA_NAME = 'unique keys';
-var UNIQUE_KEYS_RATE = 900000; // 15 minutes
-/**
- * Submitter that periodically posts impression counts
- */
-export function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
-    var isClientSide = key !== undefined;
-    var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
-    var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE, DATA_NAME);
-    // register unique keys submitter to be executed when uniqueKeys cache is full
-    uniqueKeys.setOnFullQueueCb(function () {
-        if (syncTask.isRunning()) {
-            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
-            syncTask.execute();
-        }
-        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
-        // Data will be sent when submitter is resumed.
-    });
-    return syncTask;
-}

package/esm/sync/syncManagerOnline.js

@@ -1,168 +0,0 @@
-import { submitterManagerFactory } from './submitters/submitterManager';
-import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
-import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
-import { isConsentGranted } from '../consent';
-import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
-import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
-import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
-/**
- * Online SyncManager factory.
- * Can be used for server-side API, and client-side API with or without multiple clients.
- *
- * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
- * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
- * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
- */
-export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
-    /**
-     * SyncManager factory for modular SDK
-     */
-    return function (params) {
-        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker, storage = params.storage, readiness = params.readiness;
-        /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
-        /** Push Manager */
-        var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
-            pushManagerFactory(params, pollingManager) :
-            undefined;
-        /** Submitter Manager */
-        // It is not inyected as push and polling managers, because at the moment it is required
-        var submitterManager = submitterManagerFactory(params);
-        /** Sync Manager logic */
-        function startPolling() {
-            if (pollingManager.isRunning()) {
-                log.info(SYNC_CONTINUE_POLLING);
-            }
-            else {
-                log.info(SYNC_START_POLLING);
-                pollingManager.start();
-                telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, POLLING);
-            }
-        }
-        function stopPollingAndSyncAll() {
-            log.info(SYNC_STOP_POLLING);
-            // if polling, stop
-            if (pollingManager.isRunning()) {
-                pollingManager.stop();
-                telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, STREAMING);
-            }
-            // fetch splits and segments. There is no need to catch this promise (it is always resolved)
-            pollingManager.syncAll();
-        }
-        if (pushManager) {
-            pushManager.on(PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
-            pushManager.on(PUSH_SUBSYSTEM_DOWN, startPolling);
-        }
-        var running = false; // flag that indicates whether the syncManager has been started (true) or stopped (false)
-        var startFirstTime = true; // flag to distinguish calling the `start` method for the first time, to support pausing and resuming the synchronization
-        return {
-            // Exposed for fine-grained control of synchronization.
-            // E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).
-            pollingManager: pollingManager,
-            pushManager: pushManager,
-            submitterManager: submitterManager,
-            /**
-             * Method used to start the syncManager for the first time, or resume it after being stopped.
-             */
-            start: function () {
-                running = true;
-                if (startFirstTime) {
-                    var isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
-                    if (isCacheLoaded)
-                        Promise.resolve().then(function () { readiness.splits.emit(SDK_SPLITS_CACHE_LOADED); });
-                }
-                // start syncing splits and segments
-                if (pollingManager) {
-                    // If synchronization is disabled pushManager and pollingManager should not start
-                    if (syncEnabled) {
-                        if (pushManager) {
-                            // Doesn't call `syncAll` when the syncManager is resuming
-                            if (startFirstTime) {
-                                pollingManager.syncAll();
-                            }
-                            pushManager.start();
-                        }
-                        else {
-                            pollingManager.start();
-                        }
-                    }
-                    else {
-                        if (startFirstTime) {
-                            pollingManager.syncAll();
-                        }
-                    }
-                }
-                // start periodic data recording (events, impressions, telemetry).
-                submitterManager.start(!isConsentGranted(settings));
-                startFirstTime = false;
-            },
-            /**
-             * Method used to stop/pause the syncManager.
-             */
-            stop: function () {
-                running = false;
-                // stop syncing
-                if (pushManager)
-                    pushManager.stop();
-                if (pollingManager && pollingManager.isRunning())
-                    pollingManager.stop();
-                // stop periodic data recording (events, impressions, telemetry).
-                submitterManager.stop();
-            },
-            isRunning: function () {
-                return running;
-            },
-            flush: function () {
-                return submitterManager.execute(!isConsentGranted(settings));
-            },
-            // [Only used for client-side]
-            // If polling and push managers are defined (standalone mode), they implement the interfaces for client-side
-            shared: function (matchingKey, readinessManager, storage) {
-                if (!pollingManager)
-                    return;
-                var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
-                if (syncEnabled && pushManager)
-                    pushManager.add(matchingKey, mySegmentsSyncTask);
-                if (running) {
-                    if (syncEnabled) {
-                        if (pushManager) {
-                            if (pollingManager.isRunning()) {
-                                // if doing polling, we must start the periodic fetch of data
-                                if (usesSegmentsSync(storage))
-                                    mySegmentsSyncTask.start();
-                            }
-                            else {
-                                // if not polling, we must execute the sync task for the initial fetch
-                                // of segments since `syncAll` was already executed when starting the main client
-                                mySegmentsSyncTask.execute();
-                            }
-                        }
-                        else {
-                            if (usesSegmentsSync(storage))
-                                mySegmentsSyncTask.start();
-                        }
-                    }
-                    else {
-                        if (!readinessManager.isReady())
-                            mySegmentsSyncTask.execute();
-                    }
-                }
-                return {
-                    stop: function () {
-                        // check in case `client.destroy()` has been invoked more than once for the same client
-                        var mySegmentsSyncTask = pollingManager.get(matchingKey);
-                        if (mySegmentsSyncTask) {
-                            // stop syncing
-                            if (pushManager)
-                                pushManager.remove(matchingKey);
-                            if (mySegmentsSyncTask.isRunning())
-                                mySegmentsSyncTask.stop();
-                            pollingManager.remove(matchingKey);
-                        }
-                    },
-                    flush: function () { return Promise.resolve(); }
-                };
-            }
-        };
-    };
-}

package/esm/sync/syncTask.js

@@ -1,80 +0,0 @@
-import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/constants';
-/**
- * Creates an object that handles the periodic execution of a given task via "start" and "stop" methods.
- * The task can be also executed by calling the "execute" method. Multiple calls run sequentially to avoid race conditions (e.g., submitters executed on SDK destroy or full queue, while periodic execution is pending).
- *
- * @param log -  Logger instance.
- * @param task -  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
- * @param period -  Period in milliseconds to execute the task.
- * @param taskName -  Optional task name for logging.
- * @returns A sync task that wraps the given task.
- */
-export function syncTaskFactory(log, task, period, taskName) {
-    if (taskName === void 0) { taskName = 'task'; }
-    // Flag that indicates if the task is executing
-    var executing = 0;
-    // Promise chain to resolve tasks sequentially
-    var promiseChain;
-    // flag that indicates if the task periodic execution has been started/stopped.
-    var running = false;
-    // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
-    var runningId = 0;
-    // Params passed to `task` when called periodically
-    var runningArgs;
-    // Id of the periodic call timeout
-    var timeoutID;
-    function execute() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        executing++;
-        log.debug(SYNC_TASK_EXECUTE, [taskName]);
-        // Update `promiseChain` with last promise, to run tasks serially
-        promiseChain = (promiseChain ? promiseChain.then(function () { return task.apply(void 0, args); }) : task.apply(void 0, args))
-            .then(function (result) {
-            executing--;
-            return result;
-        });
-        return promiseChain;
-    }
-    function periodicExecute(currentRunningId) {
-        return execute.apply(void 0, runningArgs).then(function (result) {
-            // Call `setTimeout` if periodic execution was started and `currentRunningId === runningId`
-            // to avoid a race condition when calling `start`, `stop` and `start` again
-            if (running && currentRunningId === runningId)
-                timeoutID = setTimeout(periodicExecute, period, currentRunningId);
-            return result;
-        });
-    }
-    return {
-        execute: execute,
-        isExecuting: function () {
-            return executing > 0;
-        },
-        start: function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (!running) {
-                running = true;
-                runningId++;
-                runningArgs = args;
-                log.debug(SYNC_TASK_START, [taskName, period]);
-                return periodicExecute(runningId);
-            }
-        },
-        stop: function () {
-            if (running) {
-                running = false;
-                log.debug(SYNC_TASK_STOP, [taskName]);
-                clearTimeout(timeoutID);
-                timeoutID = undefined;
-            }
-        },
-        isRunning: function () {
-            return running;
-        }
-    };
-}

package/esm/sync/types.js

@@ -1 +0,0 @@
-export {};

package/esm/trackers/eventTracker.js

@@ -1,58 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { thenable } from '../utils/promise/thenable';
-import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
-import { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
-/**
- * Event tracker stores events in cache and pass them to the integrations manager if provided.
- *
- * @param eventsCache - cache to save events
- * @param integrationsManager - optional event handler used for integrations
- */
-export function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
-    var log = settings.log, mode = settings.mode;
-    var isAsync = isConsumerMode(mode);
-    function queueEventsCallback(eventData, tracked) {
-        var eventTypeId = eventData.eventTypeId, trafficTypeName = eventData.trafficTypeName, key = eventData.key, value = eventData.value, timestamp = eventData.timestamp, properties = eventData.properties;
-        // Logging every prop would be too much.
-        var msg = "event of type \"" + eventTypeId + "\" for traffic type \"" + trafficTypeName + "\". Key: " + key + ". Value: " + value + ". Timestamp: " + timestamp + ". " + (properties ? 'With properties.' : 'With no properties.');
-        if (tracked) {
-            log.info(EVENTS_TRACKER_SUCCESS, [msg]);
-            if (integrationsManager) {
-                whenInit(function () {
-                    // Wrap in a timeout because we don't want it to be blocking.
-                    setTimeout(function () {
-                        // copy of event, to avoid unexpected behavior if modified by integrations
-                        var eventDataCopy = objectAssign({}, eventData);
-                        if (properties)
-                            eventDataCopy.properties = objectAssign({}, properties);
-                        // integrationsManager does not throw errors (they are internally handled by each integration module)
-                        integrationsManager.handleEvent(eventDataCopy);
-                    });
-                });
-            }
-        }
-        else {
-            log.error(ERROR_EVENTS_TRACKER, [msg]);
-        }
-        return tracked;
-    }
-    return {
-        track: function (eventData, size) {
-            if (settings.userConsent === CONSENT_DECLINED) {
-                return isAsync ? Promise.resolve(false) : false;
-            }
-            var tracked = eventsCache.track(eventData, size);
-            if (thenable(tracked)) {
-                return tracked.then(queueEventsCallback.bind(null, eventData));
-            }
-            else {
-                // Record when eventsCache is sync only (standalone mode)
-                // @TODO we are not dropping events on full queue yet, so `tracked` is always true ATM
-                if (telemetryCache)
-                    telemetryCache.recordEventStats(tracked ? QUEUED : DROPPED, 1);
-                return queueEventsCallback(eventData, tracked);
-            }
-        }
-    };
-}

package/esm/trackers/impressionObserver/ImpressionObserver.js

@@ -1,15 +0,0 @@
-import { LRUCache } from '../../utils/LRUCache';
-var ImpressionObserver = /** @class */ (function () {
-    function ImpressionObserver(size, hasher) {
-        this.cache = new LRUCache(size);
-        this.hasher = hasher;
-    }
-    ImpressionObserver.prototype.testAndSet = function (impression) {
-        var hash = this.hasher(impression);
-        var previous = this.cache.get(hash);
-        this.cache.set(hash, impression.time);
-        return previous;
-    };
-    return ImpressionObserver;
-}());
-export { ImpressionObserver };

package/esm/trackers/impressionObserver/buildKey.js

@@ -1,3 +0,0 @@
-export function buildKey(impression) {
-    return impression.keyName + ":" + impression.feature + ":" + impression.treatment + ":" + impression.label + ":" + impression.changeNumber;
-}

package/esm/trackers/impressionObserver/impressionObserverCS.js

@@ -1,10 +0,0 @@
-import { ImpressionObserver } from './ImpressionObserver';
-import { hash } from '../../utils/murmur3/murmur3';
-import { buildKey } from './buildKey';
-export function hashImpression32(impression) {
-    return hash(buildKey(impression));
-}
-var LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes
-export function impressionObserverCSFactory() {
-    return new ImpressionObserver(LAST_SEEN_CACHE_SIZE, hashImpression32);
-}

package/esm/trackers/impressionObserver/impressionObserverSS.js

@@ -1,10 +0,0 @@
-import { ImpressionObserver } from './ImpressionObserver';
-import { hash128 } from '../../utils/murmur3/murmur3_128_x86';
-import { buildKey } from './buildKey';
-export function hashImpression128(impression) {
-    return hash128(buildKey(impression));
-}
-var LAST_SEEN_CACHE_SIZE = 500000; // cache up to 500k impression hashes
-export function impressionObserverSSFactory() {
-    return new ImpressionObserver(LAST_SEEN_CACHE_SIZE, hashImpression128);
-}

package/esm/trackers/impressionObserver/types.js

@@ -1 +0,0 @@
-export {};

package/esm/trackers/impressionsTracker.js

@@ -1,74 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { thenable } from '../utils/promise/thenable';
-import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
-import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
-/**
- * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
- */
-export function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, strategy, whenInit, integrationsManager, telemetryCache) {
-    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
-    return {
-        track: function (impressions, attributes) {
-            if (settings.userConsent === CONSENT_DECLINED)
-                return;
-            var impressionsToStore = impressions.filter(function (_a) {
-                var imp = _a.imp, disabled = _a.disabled;
-                return disabled ?
-                    noneStrategy.process(imp) :
-                    strategy.process(imp);
-            });
-            var impressionsLength = impressions.length;
-            var impressionsToStoreLength = impressionsToStore.length;
-            if (impressionsToStoreLength) {
-                var res = impressionsCache.track(impressionsToStore.map(function (item) { return item.imp; }));
-                // If we're on an async storage, handle error and log it.
-                if (thenable(res)) {
-                    res.then(function () {
-                        log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsLength]);
-                    }).catch(function (err) {
-                        log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsLength, err]);
-                    });
-                }
-                else {
-                    // Record when impressionsCache is sync only (standalone mode)
-                    // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-                    if (telemetryCache) {
-                        telemetryCache.recordImpressionStats(QUEUED, impressionsToStoreLength);
-                        telemetryCache.recordImpressionStats(DEDUPED, impressionsLength - impressionsToStoreLength);
-                    }
-                }
-            }
-            // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
-            if (impressionListener || integrationsManager) {
-                var _loop_1 = function (i) {
-                    var impressionData = {
-                        // copy of impression, to avoid unexpected behavior if modified by integrations or impressionListener
-                        impression: objectAssign({}, impressions[i].imp),
-                        attributes: attributes,
-                        ip: ip,
-                        hostname: hostname,
-                        sdkLanguageVersion: version
-                    };
-                    whenInit(function () {
-                        // Wrap in a timeout because we don't want it to be blocking.
-                        setTimeout(function () {
-                            // integrationsManager.handleImpression does not throw errors
-                            if (integrationsManager)
-                                integrationsManager.handleImpression(impressionData);
-                            try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                                if (impressionListener)
-                                    impressionListener.logImpression(impressionData);
-                            }
-                            catch (err) {
-                                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-                            }
-                        });
-                    });
-                };
-                for (var i = 0; i < impressionsLength; i++) {
-                    _loop_1(i);
-                }
-            }
-        }
-    };
-}

package/esm/trackers/strategy/strategyDebug.js

@@ -1,16 +0,0 @@
-/**
- * Debug strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
- *
- * @param impressionsObserver - impression observer. Previous time (pt property) is included in impression instances
- * @returns Debug strategy
- */
-export function strategyDebugFactory(impressionsObserver) {
-    return {
-        process: function (impression) {
-            if (impression.properties)
-                return true;
-            impression.pt = impressionsObserver.testAndSet(impression);
-            return true;
-        }
-    };
-}

package/esm/trackers/strategy/strategyNone.js

@@ -1,20 +0,0 @@
-/**
- * None strategy for impressions tracker.
- *
- * @param impressionCounts - cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
- * @param uniqueKeysTracker - unique keys tracker in charge of tracking the unique keys per split.
- * @returns None strategy
- */
-export function strategyNoneFactory(impressionCounts, uniqueKeysTracker) {
-    return {
-        process: function (impression) {
-            var now = Date.now();
-            // Increments impression counter per featureName
-            impressionCounts.track(impression.feature, now, 1);
-            // Keep track by unique key
-            uniqueKeysTracker.track(impression.keyName, impression.feature);
-            // Do not store impressions
-            return false;
-        }
-    };
-}

package/esm/trackers/strategy/strategyOptimized.js

@@ -1,24 +0,0 @@
-import { truncateTimeFrame } from '../../utils/time';
-/**
- * Optimized strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
- *
- * @param impressionsObserver - impression observer. previous time (pt property) is included in impression instances
- * @param impressionCounts - cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
- * @returns Optimized strategy
- */
-export function strategyOptimizedFactory(impressionsObserver, impressionCounts) {
-    return {
-        process: function (impression) {
-            // DEBUG mode without previous time, for impressions with properties
-            if (impression.properties)
-                return true;
-            impression.pt = impressionsObserver.testAndSet(impression);
-            var now = Date.now();
-            // Increments impression counter per featureName
-            if (impression.pt)
-                impressionCounts.track(impression.feature, now, 1);
-            // Checks if the impression should be added in queue to be sent
-            return (!impression.pt || impression.pt < truncateTimeFrame(now)) ? true : false;
-        }
-    };
-}