@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/lib/sync/constants.js

@@ -0,0 +1,59 @@
+"use strict";
+
+exports.__esModule = true;
+exports.ControlTypes = exports.OCCUPANCY = exports.CONTROL = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MY_SEGMENTS_UPDATE_V2 = exports.MY_SEGMENTS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NONRETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
+// time for refresh token
+var SECONDS_BEFORE_EXPIRATION = 600; // Internal SDK events, subscribed by SyncManager and PushManager
+
+/**
+ * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false
+ * triggers `handleNonRetryableError` call
+ */
+
+exports.SECONDS_BEFORE_EXPIRATION = SECONDS_BEFORE_EXPIRATION;
+var PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
+/**
+ * emitted on SSE and Authenticate recoverable errors
+ * triggers `handleRetryableError` call
+ */
+
+exports.PUSH_NONRETRYABLE_ERROR = PUSH_NONRETRYABLE_ERROR;
+var PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
+/**
+ * emitted on STREAMING_RESUMED control notification, OCCUPANCY different than 0, and SSE onopen event
+ * triggers `stopPollingAndSyncAll` call
+ */
+
+exports.PUSH_RETRYABLE_ERROR = PUSH_RETRYABLE_ERROR;
+var PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
+/**
+ * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
+ * triggers `startPolling` and `stopWorkers` calls
+ */
+
+exports.PUSH_SUBSYSTEM_UP = PUSH_SUBSYSTEM_UP;
+var PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'; // Update-type push notifications, handled by NotificationProcessor
+
+exports.PUSH_SUBSYSTEM_DOWN = PUSH_SUBSYSTEM_DOWN;
+var MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+exports.MY_SEGMENTS_UPDATE = MY_SEGMENTS_UPDATE;
+var MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+exports.MY_SEGMENTS_UPDATE_V2 = MY_SEGMENTS_UPDATE_V2;
+var SEGMENT_UPDATE = 'SEGMENT_UPDATE';
+exports.SEGMENT_UPDATE = SEGMENT_UPDATE;
+var SPLIT_KILL = 'SPLIT_KILL';
+exports.SPLIT_KILL = SPLIT_KILL;
+var SPLIT_UPDATE = 'SPLIT_UPDATE'; // Control-type push notifications, handled by NotificationKeeper
+
+exports.SPLIT_UPDATE = SPLIT_UPDATE;
+var CONTROL = 'CONTROL';
+exports.CONTROL = CONTROL;
+var OCCUPANCY = 'OCCUPANCY';
+exports.OCCUPANCY = OCCUPANCY;
+var ControlTypes = {
+  STREAMING_DISABLED: 'STREAMING_DISABLED',
+  STREAMING_PAUSED: 'STREAMING_PAUSED',
+  STREAMING_RESUMED: 'STREAMING_RESUMED',
+  STREAMING_RESET: 'STREAMING_RESET'
+};
+exports.ControlTypes = ControlTypes;

package/lib/sync/node.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = NodeSyncManagerFactory;
+
+var _PushManager = _interopRequireDefault(require("./PushManager"));
+
+var _producer = _interopRequireDefault(require("../producer"));
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _constants = require("./constants");
+
+var log = (0, _logger.default)('splitio-sync:sync-manager');
+/**
+ * Factory of SyncManager for node
+ *
+ * @param context main client context
+ */
+
+function NodeSyncManagerFactory(context) {
+  var producer = (0, _producer.default)(context);
+  var settings = context.get(context.constants.SETTINGS); // add producer into the context before creating the PushManager
+
+  context.put(context.constants.PRODUCER, producer);
+  var pushManager = settings.streamingEnabled ? (0, _PushManager.default)(context) : undefined;
+
+  function startPolling() {
+    if (!producer.isRunning()) {
+      log.info('Streaming not available. Starting periodic fetch of data.');
+      producer.start();
+    } else {
+      log.info('Streaming couldn\'t connect. Continue periodic fetch of data.');
+    }
+  }
+
+  function stopPollingAndSyncAll() {
+    log.info('PUSH (re)connected. Syncing and stopping periodic fetch of data.'); // if polling, stop
+
+    if (producer.isRunning()) producer.stop();
+    syncAll();
+  }
+
+  function syncAll() {
+    // fetch splits and segments. There is no need to catch this promise (it is handled by `SplitChangesUpdater`)
+    producer.synchronizeSplits().then(function () {
+      producer.synchronizeSegment();
+    });
+  }
+
+  return {
+    start: function start() {
+      // start syncing
+      if (pushManager) {
+        syncAll();
+        pushManager.on(_constants.PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
+        pushManager.on(_constants.PUSH_SUBSYSTEM_DOWN, startPolling);
+        setTimeout(pushManager.start); // Run in next event-loop cycle as in browser
+      } else {
+        producer.start();
+      }
+    },
+    stop: function stop() {
+      // stop syncing
+      if (pushManager) pushManager.stop();
+      if (producer.isRunning()) producer.stop();
+    }
+  };
+}

package/lib/sync/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/lib/trackers/event.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _thenable = _interopRequireDefault(require("../utils/promise/thenable"));
+
+var log = (0, _logger.default)('splitio-client:event-tracker');
+
+function EventTracker(context) {
+  var collector = context.get(context.constants.STORAGE).events;
+  var integrationsManager = context.get(context.constants.INTEGRATIONS_MANAGER, true);
+
+  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("Successfully queued " + msg);
+
+      if (integrationsManager) {
+        // Wrap in a timeout because we don't want it to be blocking.
+        setTimeout(function () {
+          // copy of event, to avoid unexpected behaviour if modified by integrations
+          var eventDataCopy = (0, _objectAssign.default)({}, eventData);
+          if (eventData.properties) eventDataCopy.properties = (0, _objectAssign.default)({}, eventData.properties); // integrationsManager does not throw errors (they are internally handled by each integration module)
+
+          integrationsManager.handleEvent(eventDataCopy);
+        }, 0);
+      }
+    } else {
+      log.warn("Failed to queue " + msg);
+    }
+
+    return tracked;
+  }
+
+  return {
+    track: function track(eventData, size) {
+      var tracked = collector.track(eventData, size);
+
+      if ((0, _thenable.default)(tracked)) {
+        return tracked.then(queueEventsCallback.bind(null, eventData));
+      } else {
+        return queueEventsCallback(eventData, tracked);
+      }
+    }
+  };
+}
+
+var _default = EventTracker;
+exports.default = _default;

package/lib/trackers/impressions.js

@@ -0,0 +1,146 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _thenable = _interopRequireDefault(require("../utils/promise/thenable"));
+
+var _observer = _interopRequireDefault(require("../impressions/observer"));
+
+var _time = require("../utils/time");
+
+var _constants = require("../utils/constants");
+
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+var log = (0, _logger.default)('splitio-client:impressions-tracker');
+/**
+ * Checks if impressions previous time should be added or not.
+ */
+
+function shouldAddPt(settings) {
+  return [_constants.PRODUCER_MODE, _constants.STANDALONE_MODE].indexOf(settings.mode) > -1 ? true : false;
+}
+/**
+ * Checks if it should dedupe impressions or not.
+ */
+
+
+function shouldBeOptimized(settings) {
+  if (!shouldAddPt(settings)) return false;
+  return settings.sync.impressionsMode === _constants.OPTIMIZED ? true : false;
+}
+
+function ImpressionsTracker(context) {
+  var collector = context.get(context.constants.STORAGE).impressions;
+  var settings = context.get(context.constants.SETTINGS);
+  var listener = settings.impressionListener;
+  var integrationsManager = context.get(context.constants.INTEGRATIONS_MANAGER, true);
+  var _settings$runtime = settings.runtime,
+      ip = _settings$runtime.ip,
+      hostname = _settings$runtime.hostname;
+  var sdkLanguageVersion = settings.version;
+  var _queue = [];
+  var shouldAddPreviousTime = shouldAddPt(settings);
+  var isOptimized = shouldBeOptimized(settings);
+  var observer = (0, _observer.default)(); // Instantiates observer
+
+  var impressionsCounter = context.get(context.constants.IMPRESSIONS_COUNTER);
+  return {
+    queue: function queue(impression, attributes) {
+      _queue.push({
+        impression: impression,
+        attributes: attributes
+      });
+    },
+    track: function track() {
+      var impressionsCount = _queue.length;
+
+      var slice = _queue.splice(0, impressionsCount);
+
+      var impressionsToStore = []; // Track only the impressions that are going to be stored
+      // Wraps impressions to store and adds previousTime if it corresponds
+
+      slice.forEach(function (_ref) {
+        var impression = _ref.impression;
+
+        if (shouldAddPreviousTime) {
+          // Adds previous time if it is enabled
+          impression.pt = observer.testAndSet(impression);
+        }
+
+        var now = Date.now();
+
+        if (isOptimized && impressionsCounter) {
+          // Increments impression counter per featureName
+          impressionsCounter.inc(impression.feature, now, 1);
+        } // Checks if the impression should be added in queue to be sent
+
+
+        if (!isOptimized || !impression.pt || impression.pt < (0, _time.truncateTimeFrame)(now)) {
+          impressionsToStore.push(impression);
+        }
+      });
+      var res = collector.track(impressionsToStore); // If we're on an async storage, handle error and log it.
+
+      if ((0, _thenable.default)(res)) {
+        res.then(function () {
+          log.debug("Successfully stored " + impressionsCount + " impression" + (impressionsCount === 1 ? '' : 's') + ".");
+        }).catch(function (err) {
+          log.error("Could not store impressions bulk with " + impressionsCount + " impression" + (impressionsCount === 1 ? '' : 's') + ". Error: " + err);
+        });
+      }
+
+      if (listener || integrationsManager) {
+        var _loop = function _loop(i) {
+          var impressionData = {
+            // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
+            impression: (0, _objectAssign.default)({}, slice[i].impression),
+            attributes: slice[i].attributes,
+            ip: ip,
+            hostname: hostname,
+            sdkLanguageVersion: sdkLanguageVersion
+          }; // 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 {
+              // An exception on the listeners should not break the SDK.
+              if (listener) listener.logImpression(impressionData);
+            } catch (err) {
+              log.error("Impression listener logImpression method threw: " + err + ".");
+            }
+          }, 0);
+        };
+
+        for (var i = 0; i < impressionsCount; i++) {
+          _loop(i);
+        }
+      }
+    }
+  };
+}
+
+var _default = ImpressionsTracker;
+exports.default = _default;

package/lib/umd.js

@@ -5,6 +5,5 @@ exports.default = void 0;
 
 var _index = require("./index");
 
-// eslint-disable-next-line import/no-default-export
 var _default = _index.SplitFactory;
 exports.default = _default;

package/lib/utils/backoff/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var Backoff = /*#__PURE__*/function () {
+  /**
+   * Schedule function calls with exponential backoff
+   *
+   * @param {function} cb
+   * @param {number} baseMillis
+   * @param {number} maxMillis
+   */
+  function Backoff(cb, baseMillis, maxMillis) {
+    this.baseMillis = baseMillis || Backoff.DEFAULT_BASE_MILLIS;
+    this.maxMillis = maxMillis || Backoff.DEFAULT_MAX_MILLIS;
+    this.attempts = 0;
+    this.cb = cb;
+  }
+  /**
+   * Schedule a next call to `cb`
+   * @returns scheduled delay in milliseconds
+   */
+
+
+  var _proto = Backoff.prototype;
+
+  _proto.scheduleCall = function scheduleCall() {
+    var _this = this;
+
+    var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
+    if (this.timeoutID) clearTimeout(this.timeoutID);
+    this.timeoutID = setTimeout(function () {
+      _this.cb();
+    }, delayInMillis);
+    this.attempts++;
+    return delayInMillis;
+  };
+
+  _proto.reset = function reset() {
+    this.attempts = 0;
+
+    if (this.timeoutID) {
+      clearTimeout(this.timeoutID);
+      this.timeoutID = 0;
+    }
+  };
+
+  return Backoff;
+}();
+
+Backoff.DEFAULT_BASE_MILLIS = 1000; // 1 second
+
+Backoff.DEFAULT_MAX_MILLIS = 1800000; // 30 minutes
+
+var _default = Backoff;
+exports.default = _default;

package/lib/utils/base64/browser.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports.decodeFromBase64 = decodeFromBase64;
+exports.encodeToBase64 = encodeToBase64;
+
+/**
+ * Decode a given string value in Base64 format
+ *
+ * @param {string} value to decode
+ * @throws {ReferenceError} if `atob` function is not defined
+ */
+function decodeFromBase64(value) {
+  return atob(value);
+}
+/**
+ * Encode a given string value to Base64 format.
+ *
+ * @param {string} value to encode
+ * @throws {ReferenceError} if `btoa` function is not defined
+ */
+
+
+function encodeToBase64(value) {
+  return btoa(value);
+}

package/lib/utils/base64/node.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports.decodeFromBase64 = decodeFromBase64;
+exports.encodeToBase64 = encodeToBase64;
+
+/**
+ * Decode a given string value in Base64 format
+ *
+ * @param {string} value to decode
+ */
+function decodeFromBase64(value) {
+  // for node (version mayor than v4)
+  return Buffer.from(value, 'base64').toString('binary');
+}
+/**
+ * Encode a given string value to Base64 format
+ *
+ * @param {string} value to encode
+ */
+
+
+function encodeToBase64(value) {
+  // for node (version mayor than v4)
+  return Buffer.from(value).toString('base64');
+}

package/lib/utils/base64/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/lib/utils/binarySearch/index.js

@@ -0,0 +1,56 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+function bs(items, value) {
+  var startIndex = 0;
+  var stopIndex = items.length - 1;
+  var middle = Math.floor((stopIndex + startIndex) / 2);
+  var minIndex = startIndex;
+  var maxIndex = stopIndex;
+
+  while (items[middle] !== value && startIndex < stopIndex) {
+    // adjust search area
+    if (value < items[middle]) {
+      stopIndex = middle - 1;
+    } else if (value > items[middle]) {
+      startIndex = middle + 1;
+    } // recalculate middle
+
+
+    middle = Math.floor((stopIndex + startIndex) / 2);
+  } // correct if middle is out of range
+
+
+  if (middle < minIndex) {
+    middle = minIndex;
+  } else if (middle > maxIndex) {
+    middle = maxIndex;
+  } // we want to always return based on strict minor comparation
+
+
+  if (value < items[middle] && middle > minIndex) {
+    return middle - 1;
+  }
+
+  return middle;
+}
+
+var _default = bs;
+exports.default = _default;

package/lib/utils/constants/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.OPTIMIZED = exports.DEBUG = exports.FILTERS_METADATA = exports.SPLIT_EVENT = exports.SPLIT_IMPRESSION = exports.SPLIT_TO_GOOGLE_ANALYTICS = exports.GOOGLE_ANALYTICS_TO_SPLIT = exports.NA = exports.UNKNOWN = exports.CONTROL_WITH_CONFIG = exports.CONTROL = exports.STORAGE_LOCALSTORAGE = exports.STORAGE_REDIS = exports.STORAGE_MEMORY = exports.CONSUMER_MODE = exports.PRODUCER_MODE = exports.STANDALONE_MODE = exports.LOCALHOST_MODE = void 0;
+// SDK Modes
+var LOCALHOST_MODE = 'localhost';
+exports.LOCALHOST_MODE = LOCALHOST_MODE;
+var STANDALONE_MODE = 'standalone';
+exports.STANDALONE_MODE = STANDALONE_MODE;
+var PRODUCER_MODE = 'producer';
+exports.PRODUCER_MODE = PRODUCER_MODE;
+var CONSUMER_MODE = 'consumer'; // Storage types
+
+exports.CONSUMER_MODE = CONSUMER_MODE;
+var STORAGE_MEMORY = 'MEMORY';
+exports.STORAGE_MEMORY = STORAGE_MEMORY;
+var STORAGE_REDIS = 'REDIS';
+exports.STORAGE_REDIS = STORAGE_REDIS;
+var STORAGE_LOCALSTORAGE = 'LOCALSTORAGE'; // Special treatments
+
+exports.STORAGE_LOCALSTORAGE = STORAGE_LOCALSTORAGE;
+var CONTROL = 'control';
+exports.CONTROL = CONTROL;
+var CONTROL_WITH_CONFIG = {
+  treatment: CONTROL,
+  config: null
+}; // Constants for unknown and not-applicable values
+
+exports.CONTROL_WITH_CONFIG = CONTROL_WITH_CONFIG;
+var UNKNOWN = 'unknown';
+exports.UNKNOWN = UNKNOWN;
+var NA = 'NA'; // Integration types
+
+exports.NA = NA;
+var GOOGLE_ANALYTICS_TO_SPLIT = 'GOOGLE_ANALYTICS_TO_SPLIT';
+exports.GOOGLE_ANALYTICS_TO_SPLIT = GOOGLE_ANALYTICS_TO_SPLIT;
+var SPLIT_TO_GOOGLE_ANALYTICS = 'SPLIT_TO_GOOGLE_ANALYTICS'; // Integration data types
+
+exports.SPLIT_TO_GOOGLE_ANALYTICS = SPLIT_TO_GOOGLE_ANALYTICS;
+var SPLIT_IMPRESSION = 'IMPRESSION';
+exports.SPLIT_IMPRESSION = SPLIT_IMPRESSION;
+var SPLIT_EVENT = 'EVENT'; // Split filters metadata.
+// Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
+
+exports.SPLIT_EVENT = SPLIT_EVENT;
+var FILTERS_METADATA = [{
+  type: 'byName',
+  maxLength: 400,
+  queryParam: 'names='
+}, {
+  type: 'byPrefix',
+  maxLength: 50,
+  queryParam: 'prefixes='
+}]; // Impression collection modes
+
+exports.FILTERS_METADATA = FILTERS_METADATA;
+var DEBUG = 'DEBUG';
+exports.DEBUG = DEBUG;
+var OPTIMIZED = 'OPTIMIZED';
+exports.OPTIMIZED = OPTIMIZED;

package/lib/utils/context/constants.js

@@ -0,0 +1,49 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.IMPRESSIONS_COUNTER = exports.STORAGE = exports.STATUS_MANAGER = exports.SETTINGS = exports.READY_FROM_CACHE = exports.READY = exports.READINESS = exports.PRODUCER = exports.MY_SEGMENTS_CHANGE_WORKER = exports.INTEGRATIONS_MANAGER = exports.HAS_TIMEDOUT = exports.EVENTS = exports.DESTROYED = exports.COLLECTORS = void 0;
+var COLLECTORS = 'metrics_collectors';
+exports.COLLECTORS = COLLECTORS;
+var DESTROYED = 'is_destroyed';
+exports.DESTROYED = DESTROYED;
+var EVENTS = 'events_publisher';
+exports.EVENTS = EVENTS;
+var HAS_TIMEDOUT = 'has_timedout';
+exports.HAS_TIMEDOUT = HAS_TIMEDOUT;
+var INTEGRATIONS_MANAGER = 'integrations_manager';
+exports.INTEGRATIONS_MANAGER = INTEGRATIONS_MANAGER;
+var MY_SEGMENTS_CHANGE_WORKER = 'my_segments_change_worker';
+exports.MY_SEGMENTS_CHANGE_WORKER = MY_SEGMENTS_CHANGE_WORKER;
+var PRODUCER = 'producer';
+exports.PRODUCER = PRODUCER;
+var READINESS = 'readiness_gate';
+exports.READINESS = READINESS;
+var READY = 'is_ready';
+exports.READY = READY;
+var READY_FROM_CACHE = 'is_ready_from_cache';
+exports.READY_FROM_CACHE = READY_FROM_CACHE;
+var SETTINGS = 'settings';
+exports.SETTINGS = SETTINGS;
+var STATUS_MANAGER = 'status_manager';
+exports.STATUS_MANAGER = STATUS_MANAGER;
+var STORAGE = 'storage';
+exports.STORAGE = STORAGE;
+var IMPRESSIONS_COUNTER = 'impressions_counter';
+exports.IMPRESSIONS_COUNTER = IMPRESSIONS_COUNTER;
+var _default = {
+  COLLECTORS: COLLECTORS,
+  DESTROYED: DESTROYED,
+  EVENTS: EVENTS,
+  HAS_TIMEDOUT: HAS_TIMEDOUT,
+  INTEGRATIONS_MANAGER: INTEGRATIONS_MANAGER,
+  MY_SEGMENTS_CHANGE_WORKER: MY_SEGMENTS_CHANGE_WORKER,
+  PRODUCER: PRODUCER,
+  READINESS: READINESS,
+  READY: READY,
+  READY_FROM_CACHE: READY_FROM_CACHE,
+  SETTINGS: SETTINGS,
+  STATUS_MANAGER: STATUS_MANAGER,
+  STORAGE: STORAGE,
+  IMPRESSIONS_COUNTER: IMPRESSIONS_COUNTER
+};
+exports.default = _default;