@splitsoftware/splitio 10.17.3-rc.1 → 10.17.3-rc.4

package/lib/impressions/hasher/hashImpression32.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.hashImpression32 = hashImpression32;
+
+var _murmur = _interopRequireDefault(require("../../engine/engine/murmur3/murmur3"));
+
+var _buildKey = require("./buildKey");
+
+function hashImpression32(impression) {
+  return _murmur.default.hash((0, _buildKey.buildKey)(impression));
+}

package/lib/impressions/observer/browser.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _observer = _interopRequireDefault(require("./observer"));
+
+var _hashImpression = require("../hasher/hashImpression32");
+
+var LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes
+
+var BrowserImpressionObserverFactory = function BrowserImpressionObserverFactory() {
+  return new _observer.default(LAST_SEEN_CACHE_SIZE, _hashImpression.hashImpression32);
+};
+
+var _default = BrowserImpressionObserverFactory;
+exports.default = _default;

package/lib/impressions/observer/node.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _observer = _interopRequireDefault(require("./observer"));
+
+var _hashImpression = require("../hasher/hashImpression128");
+
+var LAST_SEEN_CACHE_SIZE = 500000; // cache up to 500k impression hashes
+
+var NodeImpressionObserverFactory = function NodeImpressionObserverFactory() {
+  return new _observer.default(LAST_SEEN_CACHE_SIZE, _hashImpression.hashImpression128);
+};
+
+var _default = NodeImpressionObserverFactory;
+exports.default = _default;

package/lib/impressions/observer/observer.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _lrucache = _interopRequireDefault(require("../../utils/lrucache/lrucache"));
+
+var ImpressionObserver = /*#__PURE__*/function () {
+  function ImpressionObserver(size, hasher) {
+    this.cache = new _lrucache.default(size);
+    this.hasher = hasher;
+  }
+
+  var _proto = ImpressionObserver.prototype;
+
+  _proto.testAndSet = function testAndSet(impression) {
+    var hash = this.hasher(impression);
+    var previous = this.cache.get(hash);
+    this.cache.set(hash, impression.time);
+    return previous;
+  };
+
+  return ImpressionObserver;
+}();
+
+var _default = ImpressionObserver;
+exports.default = _default;

package/lib/impressions/observer/package.json

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

package/lib/index.js

@@ -1,8 +1,156 @@
 "use strict";
 
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 exports.__esModule = true;
-exports.SplitFactory = void 0;
+exports.SplitFactory = SplitFactory;
+
+var _manager = _interopRequireDefault(require("./manager"));
+
+var _storage = _interopRequireDefault(require("./storage"));
+
+var _readiness2 = _interopRequireDefault(require("./readiness"));
+
+var _settings = _interopRequireDefault(require("./utils/settings"));
+
+var _context = _interopRequireDefault(require("./utils/context"));
+
+var _parser = _interopRequireDefault(require("./utils/key/parser"));
+
+var _logger = _interopRequireWildcard(require("./utils/logger"));
+
+var _timeTracker = _interopRequireDefault(require("./utils/timeTracker"));
+
+var _online = _interopRequireDefault(require("./factory/online"));
+
+var _offline = _interopRequireDefault(require("./factory/offline"));
+
+var _statusManager = _interopRequireDefault(require("./readiness/statusManager"));
+
+var _constants = require("./utils/constants");
+
+var _inputValidation = require("./utils/inputValidation");
+
+var _integrations = _interopRequireDefault(require("./integrations"));
+
+var _counter = _interopRequireDefault(require("./impressions/counter"));
+
+var log = (0, _logger.default)('splitio');
+
+var buildInstanceId = function buildInstanceId(key, trafficType) {
+  return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType !== undefined ? trafficType : '');
+};
+
+function SplitFactory(config) {
+  // Cache instances created per factory.
+  var clientInstances = {}; // Tracking times. We need to do it here because we need the storage created.
+
+  var readyLatencyTrackers = {
+    splitsReadyTracker: _timeTracker.default.start(_timeTracker.default.TaskNames.SPLITS_READY),
+    segmentsReadyTracker: _timeTracker.default.start(_timeTracker.default.TaskNames.SEGMENTS_READY),
+    sdkReadyTracker: _timeTracker.default.start(_timeTracker.default.TaskNames.SDK_READY)
+  };
+  var context = new _context.default(); // Put settings config within context
+
+  var settings = (0, _settings.default)(config);
+  context.put(context.constants.SETTINGS, settings); // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+
+  (0, _inputValidation.validateApiKey)(settings.core.authorizationKey); // Put readiness and statusManager within context
+  // Done before adding storage, to let it access readiness gate synchronously
+
+  var gateFactory = (0, _readiness2.default)();
+  var readiness = gateFactory(settings.startup.readyTimeout);
+  context.put(context.constants.READINESS, readiness);
+  var statusManager = (0, _statusManager.default)(context);
+  context.put(context.constants.STATUS_MANAGER, statusManager); // Put storage config within context
+
+  var storage = (0, _storage.default)(context);
+  context.put(context.constants.STORAGE, storage); // Put counter
+
+  var impressionsCounter = new _counter.default(); // Instantiates new counter for Impressions
+
+  context.put(context.constants.IMPRESSIONS_COUNTER, impressionsCounter); // Put integrationsManager within context.
+  // It needs to access the storage, settings and potentially other pieces, so it's registered after them.
+
+  var integrationsManager = (0, _integrations.default)(context);
+  context.put(context.constants.INTEGRATIONS_MANAGER, integrationsManager); // Define which type of factory to use
+
+  var splitFactory = settings.mode === _constants.LOCALHOST_MODE ? _offline.default : _online.default;
+
+  var _splitFactory = splitFactory(context, readyLatencyTrackers),
+      mainClientInstance = _splitFactory.api,
+      mainClientMetricCollectors = _splitFactory.metricCollectors; // It makes no sense to have multiple instances of the manager.
+
+
+  var managerInstance = (0, _manager.default)(storage.splits, context);
+  var parsedDefaultKey = (0, _parser.default)(settings.core.key);
+  var defaultInstanceId = buildInstanceId(parsedDefaultKey, settings.core.trafficType);
+  clientInstances[defaultInstanceId] = mainClientInstance;
+  log.info('New Split SDK instance created.');
+  return {
+    // Split evaluation and event tracking engine
+    client: function client(key, trafficType) {
+      if (key === undefined) {
+        log.debug('Retrieving default SDK client.');
+        return mainClientInstance;
+      }
+
+      if (typeof storage.shared != 'function') {
+        throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');
+      } // Validate the key value
+
+
+      var validKey = (0, _inputValidation.validateKey)(key, 'Shared Client instantiation');
+
+      if (validKey === false) {
+        throw new Error('Shared Client needs a valid key.');
+      }
+
+      var validTrafficType;
+
+      if (trafficType !== undefined) {
+        validTrafficType = (0, _inputValidation.validateTrafficType)(trafficType, 'Shared Client instantiation');
+
+        if (validTrafficType === false) {
+          throw new Error('Shared Client needs a valid traffic type or no traffic type at all.');
+        }
+      }
+
+      var instanceId = buildInstanceId(validKey, validTrafficType);
+
+      if (!clientInstances[instanceId]) {
+        var sharedSettings = settings.overrideKeyAndTT(validKey, validTrafficType);
+        var sharedContext = new _context.default();
+
+        var _readiness = gateFactory(sharedSettings.startup.readyTimeout);
+
+        sharedContext.put(context.constants.READY_FROM_CACHE, context.get(context.constants.READY_FROM_CACHE, true));
+        sharedContext.put(context.constants.READINESS, _readiness); // for shared clients, the internal offset of added/removed SDK_READY callbacks is -1
+
+        sharedContext.put(context.constants.STATUS_MANAGER, (0, _statusManager.default)(sharedContext, -1));
+        sharedContext.put(context.constants.SETTINGS, sharedSettings);
+        sharedContext.put(context.constants.STORAGE, storage.shared(sharedSettings));
+        sharedContext.put(context.constants.IMPRESSIONS_COUNTER, impressionsCounter); // As shared clients reuse all the storage information, we don't need to check here if we
+        // will use offline or online mode. We should stick with the original decision.
 
-var _factory = require("./factory");
+        clientInstances[instanceId] = splitFactory(sharedContext, false, mainClientMetricCollectors).api;
+        log.info('New shared client instance created.');
+      } else {
+        log.debug('Retrieving existing SDK client.');
+      }
 
-exports.SplitFactory = _factory.SplitFactory;
+      return clientInstances[instanceId];
+    },
+    // Manager API to explore available information
+    manager: function manager() {
+      log.info('Manager instance retrieved.');
+      return managerInstance;
+    },
+    // Logger wrapper API
+    Logger: _logger.API,
+    // Expose SDK settings
+    settings: settings
+  };
+}

package/lib/integrations/browser.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _GaToSplit = _interopRequireDefault(require("./ga/GaToSplit"));
+
+var _SplitToGa = _interopRequireDefault(require("./ga/SplitToGa"));
+
+var _constants = require("../utils/constants");
+
+/**
+ * Factory function for browser IntegrationsManager.
+ * The integrations manager instantiates integration modules, and bypass tracked events and impressions to them.
+ *
+ * @param {Context} context SplitFactory context
+ *
+ * @returns integration manager or null if `integrations` are not present in settings.
+ */
+var integrationsManagerFactory = function integrationsManagerFactory(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var listeners = []; // No need to check if `settings.integrations` is an array. It was already validated in settings validation
+
+  settings.integrations.forEach(function (integrationOptions) {
+    var type = integrationOptions.type;
+    var integration;
+
+    switch (type) {
+      case _constants.GOOGLE_ANALYTICS_TO_SPLIT:
+        {
+          var storage = context.get(context.constants.STORAGE);
+          var coreSettings = settings.core;
+          integration = (0, _GaToSplit.default)(integrationOptions, storage, coreSettings);
+          break;
+        }
+
+      case _constants.SPLIT_TO_GOOGLE_ANALYTICS:
+        {
+          integration = new _SplitToGa.default(integrationOptions);
+          break;
+        }
+    }
+
+    if (integration && integration.queue) listeners.push(integration);
+  }); // If `listeners` is empty, not return a integration manager
+
+  if (listeners.length === 0) return; // Exception safe methods: each integration module is responsable for handling errors
+
+  return {
+    handleImpression: function handleImpression(impressionData) {
+      listeners.forEach(function (listener) {
+        return listener.queue({
+          type: _constants.SPLIT_IMPRESSION,
+          payload: impressionData
+        });
+      });
+    },
+    handleEvent: function handleEvent(eventData) {
+      listeners.forEach(function (listener) {
+        return listener.queue({
+          type: _constants.SPLIT_EVENT,
+          payload: eventData
+        });
+      });
+    }
+  };
+};
+
+var _default = integrationsManagerFactory;
+exports.default = _default;

package/lib/integrations/ga/GaToSplit.js

@@ -0,0 +1,267 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateIdentities = validateIdentities;
+exports.validateEventData = validateEventData;
+exports.fixEventTypeId = fixEventTypeId;
+exports.default = exports.defaultPrefix = exports.defaultMapper = void 0;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var _lang = require("../../utils/lang");
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _inputValidation = require("../../utils/inputValidation");
+
+var logName = 'splitio-ga-to-split',
+    logNameMapper = logName + ':mapper';
+var log = (0, _logger.default)(logName);
+/**
+ * Provides a plugin to use with analytics.js, accounting for the possibility
+ * that the global command queue has been renamed or not yet defined.
+ * @param {string} pluginName The plugin name identifier.
+ * @param {Function} pluginConstructor The plugin constructor function.
+ */
+
+function providePlugin(pluginName, pluginConstructor) {
+  // get reference to global command queue. Init it if not defined yet.
+  var gaAlias = window.GoogleAnalyticsObject || 'ga';
+
+  window[gaAlias] = window[gaAlias] || function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    (window[gaAlias].q = window[gaAlias].q || []).push(args);
+  }; // provides the plugin for use with analytics.js.
+
+
+  window[gaAlias]('provide', pluginName, pluginConstructor);
+} // Default mapping: object used for building the default mapper from hits to Split events
+
+
+var defaultMapping = {
+  eventTypeId: {
+    event: 'eventAction',
+    social: 'socialAction'
+  },
+  eventValue: {
+    event: 'eventValue',
+    timing: 'timingValue'
+  },
+  eventProperties: {
+    pageview: ['page'],
+    screenview: ['screenName'],
+    event: ['eventCategory', 'eventLabel'],
+    social: ['socialNetwork', 'socialTarget'],
+    timing: ['timingCategory', 'timingVar', 'timingLabel'],
+    exception: ['exDescription', 'exFatal']
+  }
+};
+/**
+ * Build a mapper function based on a mapping object
+ *
+ * @param {object} mapping
+ */
+
+function mapperBuilder(mapping) {
+  return function (model) {
+    var hitType = model.get('hitType');
+    var eventTypeId = model.get(mapping.eventTypeId[hitType] || 'hitType');
+    var value = model.get(mapping.eventValue[hitType]);
+    var properties = {};
+    var fields = mapping.eventProperties[hitType];
+
+    if (fields) {
+      for (var i = 0; i < fields.length; i++) {
+        properties[fields[i]] = model.get(fields[i]);
+      }
+    }
+
+    return {
+      eventTypeId: eventTypeId,
+      value: value,
+      properties: properties,
+      timestamp: Date.now()
+    };
+  };
+} // exposed for unit testing purposses.
+
+
+var defaultMapper = mapperBuilder(defaultMapping);
+exports.defaultMapper = defaultMapper;
+var defaultPrefix = 'ga';
+/**
+ * Return a new list of identities removing invalid and duplicated ones.
+ *
+ * @param {Array} identities list of identities
+ * @returns list of valid and unique identities. The list might be empty if `identities` is not an array or all its elements are invalid.
+ */
+
+exports.defaultPrefix = defaultPrefix;
+
+function validateIdentities(identities) {
+  if (!Array.isArray(identities)) return []; // Remove duplicated identities
+
+  var uniqueIdentities = (0, _lang.unicAsStrings)(identities); // Filter based on rum-agent identities validator
+
+  return uniqueIdentities.filter(function (identity) {
+    if (!identity) return false;
+    var maybeKey = identity.key;
+    var maybeTT = identity.trafficType;
+    if (!(0, _lang.isString)(maybeKey) && !(0, _lang.numberIsFinite)(maybeKey)) return false;
+    if (!(0, _lang.isString)(maybeTT)) return false;
+    return true;
+  });
+}
+/**
+ * Checks if EventData fields (except EventTypeId) are valid, and logs corresponding warnings.
+ * EventTypeId is validated separately.
+ *
+ * @param {EventData} data event data instance to validate. Precondition: data != undefined
+ * @returns {boolean} Whether the data instance is a valid EventData or not.
+ */
+
+
+function validateEventData(eventData) {
+  if (!(0, _inputValidation.validateEvent)(eventData.eventTypeId, logNameMapper)) return false;
+  if ((0, _inputValidation.validateEventValue)(eventData.value, logNameMapper) === false) return false;
+
+  var _validateEventPropert = (0, _inputValidation.validateEventProperties)(eventData.properties, logNameMapper),
+      properties = _validateEventPropert.properties;
+
+  if (properties === false) return false;
+  if (eventData.timestamp && !(0, _lang.numberIsFinite)(eventData.timestamp)) return false;
+  if (eventData.key && (0, _inputValidation.validateKey)(eventData.key, logNameMapper) === false) return false;
+  if (eventData.trafficTypeName && (0, _inputValidation.validateTrafficType)(eventData.trafficTypeName, logNameMapper) === false) return false;
+  return true;
+}
+
+var INVALID_PREFIX_REGEX = /^[^a-zA-Z0-9]+/;
+var INVALID_SUBSTRING_REGEX = /[^-_.:a-zA-Z0-9]+/g;
+/**
+ * Fixes the passed string value to comply with EventTypeId format, by removing invalid characters and truncating if necessary.
+ *
+ * @param {string} eventTypeId string value to fix.
+ * @returns {string} Fixed version of `eventTypeId`.
+ */
+
+function fixEventTypeId(eventTypeId) {
+  // return the input eventTypeId if it cannot be fixed
+  if (!(0, _lang.isString)(eventTypeId) || eventTypeId.length === 0) {
+    return eventTypeId;
+  } // replace invalid substrings and truncate
+
+
+  var fixed = eventTypeId.replace(INVALID_PREFIX_REGEX, '').replace(INVALID_SUBSTRING_REGEX, '_');
+  var truncated = fixed.slice(0, 80);
+  if (truncated.length < fixed.length) log.warn('EventTypeId was truncated because it cannot be more than 80 characters long.');
+  return truncated;
+}
+/**
+ * GaToSplit integration.
+ * This function provides the SplitTracker plugin to ga command queue.
+ *
+ * @param {object} sdkOptions options passed at the SDK integrations settings
+ * @param {object} storage SDK storage passed to track events
+ * @param {object} coreSettings core settings used to define an identity if no one provided as SDK or plugin options
+ */
+
+
+function GaToSplit(sdkOptions, storage, coreSettings) {
+  var defaultOptions = {
+    prefix: defaultPrefix,
+    // We set default identities if key and TT are present in settings.core
+    identities: coreSettings.key && coreSettings.trafficType ? [{
+      key: coreSettings.key,
+      trafficType: coreSettings.trafficType
+    }] : undefined
+  };
+
+  var SplitTracker = // Constructor for the SplitTracker plugin.
+  function SplitTracker(tracker, pluginOptions) {
+    // precedence of options: SDK options (config.integrations) overwrite pluginOptions (`ga('require', 'splitTracker', pluginOptions)`)
+    var opts = (0, _objectAssign.default)({}, defaultOptions, sdkOptions, pluginOptions);
+    this.tracker = tracker; // Validate identities
+
+    var validIdentities = validateIdentities(opts.identities);
+
+    if (validIdentities.length === 0) {
+      log.warn('No valid identities were provided. Please check that you are passing a valid list of identities or providing a traffic type at the SDK configuration.');
+      return;
+    }
+
+    var invalids = validIdentities.length - opts.identities.length;
+
+    if (invalids) {
+      log.warn(invalids + " identities were discarded because they are invalid or duplicated. Identities must be an array of objects with key and trafficType.");
+    }
+
+    opts.identities = validIdentities; // Validate prefix
+
+    if (!(0, _lang.isString)(opts.prefix)) {
+      log.warn('The provided `prefix` was ignored since it is invalid. Please check that you are passing a string object as `prefix`.');
+      opts.prefix = undefined;
+    } // Overwrite sendHitTask to perform plugin tasks:
+    // 1) filter hits
+    // 2) map hits to Split events
+    // 3) handle events, i.e., validate and send them to Split BE
+
+
+    var originalSendHitTask = tracker.get('sendHitTask');
+    tracker.set('sendHitTask', function (model) {
+      originalSendHitTask(model); // filter hit if `hits` flag is false or if it comes from Split-to-GA integration
+
+      if (opts.hits === false || model.get('splitHit')) return;
+
+      try {
+        if (opts.filter && !opts.filter(model)) return;
+      } catch (err) {
+        log.warn("GaToSplit custom filter threw: " + err);
+        return;
+      } // map hit into an EventData instance
+
+
+      var eventData = defaultMapper(model);
+
+      if (opts.mapper) {
+        try {
+          eventData = opts.mapper(model, eventData);
+        } catch (err) {
+          log.warn("GaToSplit custom mapper threw: " + err);
+          return;
+        }
+
+        if (!eventData) return;
+      } // Add prefix. Nothing is appended if the prefix is falsy, e.g. undefined or ''.
+
+
+      if (opts.prefix) eventData.eventTypeId = opts.prefix + "." + eventData.eventTypeId;
+      eventData.eventTypeId = fixEventTypeId(eventData.eventTypeId);
+      if (!validateEventData(eventData)) return; // Store the event
+
+      if (eventData.key && eventData.trafficTypeName) {
+        storage.events.track(eventData);
+      } else {
+        // Store the event for each Key-TT pair (identities), if key and TT is not present in eventData
+        opts.identities.forEach(function (identity) {
+          var event = (0, _objectAssign.default)({
+            key: identity.key,
+            trafficTypeName: identity.trafficType
+          }, eventData);
+          storage.events.track(event);
+        });
+      }
+    });
+    log.info('Started GA-to-Split integration');
+  }; // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
+
+
+  providePlugin('splitTracker', SplitTracker);
+}
+
+var _default = GaToSplit;
+exports.default = _default;