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

package/lib/integrations/ga/SplitToGa.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _lang = require("../../utils/lang");
+
+var _constants = require("../../utils/constants");
+
+var log = (0, _logger.default)('splitio-split-to-ga');
+
+var SplitToGa = /*#__PURE__*/function () {
+  // Default mapper function.
+  SplitToGa.defaultMapper = function defaultMapper(_ref) {
+    var type = _ref.type,
+        payload = _ref.payload;
+
+    switch (type) {
+      case _constants.SPLIT_IMPRESSION:
+        return {
+          hitType: 'event',
+          eventCategory: 'split-impression',
+          eventAction: 'Evaluate ' + payload.impression.feature,
+          eventLabel: 'Treatment: ' + payload.impression.treatment + '. Targeting rule: ' + payload.impression.label + '.',
+          nonInteraction: true
+        };
+
+      case _constants.SPLIT_EVENT:
+        return {
+          hitType: 'event',
+          eventCategory: 'split-event',
+          eventAction: payload.eventTypeId,
+          eventValue: payload.value,
+          nonInteraction: true
+        };
+    }
+
+    return null;
+  } // Util to access ga command queue, accounting for the possibility that it has been renamed.
+  ;
+
+  SplitToGa.getGa = function getGa() {
+    return typeof window !== 'undefined' ? window[window['GoogleAnalyticsObject'] || 'ga'] : undefined;
+  }
+  /**
+   * Validates if a given object is a UniversalAnalytics.FieldsObject instance, and logs a warning if not.
+   * It checks that the object contains a `hitType`, since it is the minimal field required to send the hit
+   * and avoid the GA error `No hit type specified. Aborting hit.`.
+   * Other validations (e.g., an `event` hitType must have a `eventCategory` and `eventAction`) are handled
+   * and logged (as warnings or errors depending the case) by GA debugger, but the hit is sent anyway.
+   *
+   * @param {UniversalAnalytics.FieldsObject} fieldsObject object to validate.
+   * @returns {boolean} Whether the data instance is a valid FieldsObject or not.
+   */
+  ;
+
+  SplitToGa.validateFieldsObject = function validateFieldsObject(fieldsObject) {
+    if (fieldsObject && fieldsObject.hitType) return true;
+    log.warn('your custom mapper returned an invalid FieldsObject instance. It must be an object with at least a `hitType` field.');
+    return false;
+  };
+
+  function SplitToGa(options) {
+    // Check if `ga` object is available
+    if (typeof SplitToGa.getGa() !== 'function') {
+      log.warn('`ga` command queue not found. No hits will be sent.'); // Return an empty object to avoid creating a SplitToGa instance
+
+      return {};
+    }
+
+    this.trackerNames = SplitToGa.defaultTrackerNames;
+
+    if (options) {
+      if (typeof options.filter === 'function') this.filter = options.filter;
+      if (typeof options.mapper === 'function') this.mapper = options.mapper; // We strip off duplicated values if we received a `trackerNames` param.
+      // We don't warn if a tracker does not exist, since the user might create it after the SDK is initialized.
+      // Note: GA allows to create and get trackers using a string or number as tracker name, and does nothing if other types are used.
+
+      if (Array.isArray(options.trackerNames)) this.trackerNames = (0, _lang.uniq)(options.trackerNames); // No need to validate `impressions` and `events` flags. Any other value than `false` is ignored.
+
+      this.impressions = options.impressions;
+      this.events = options.events;
+    }
+
+    log.info('Started Split-to-GA integration');
+  }
+
+  var _proto = SplitToGa.prototype;
+
+  _proto.queue = function queue(data) {
+    // access ga command queue via `getGa` method, accounting for the possibility that
+    // the global `ga` reference was not yet mutated by analytics.js.
+    var ga = SplitToGa.getGa();
+
+    if (ga) {
+      if (this.impressions === false && data.type === _constants.SPLIT_IMPRESSION) return;
+      if (this.events === false && data.type === _constants.SPLIT_EVENT) return;
+      var fieldsObject;
+
+      try {
+        // only try/catch filter and mapper, which might be defined by the user
+        // filter
+        if (this.filter && !this.filter(data)) return; // map data into a FieldsObject instance
+
+        fieldsObject = SplitToGa.defaultMapper(data);
+
+        if (this.mapper) {
+          fieldsObject = this.mapper(data, fieldsObject); // don't send the hit if it is falsy or invalid
+
+          if (!fieldsObject || !SplitToGa.validateFieldsObject(fieldsObject)) return;
+        }
+      } catch (err) {
+        log.warn("SplitToGa queue method threw: " + err + ". No hit was sent.");
+        return;
+      } // send the hit
+
+
+      this.trackerNames.forEach(function (trackerName) {
+        var sendCommand = trackerName ? trackerName + ".send" : 'send'; // mark the hit as a Split one to avoid the loop.
+
+        fieldsObject.splitHit = true; // Send to GA using our reference to the GA object.
+
+        ga(sendCommand, fieldsObject);
+      });
+    }
+  };
+
+  return SplitToGa;
+}(); // A falsy object represents the default tracker
+
+
+SplitToGa.defaultTrackerNames = [''];
+var _default = SplitToGa;
+exports.default = _default;

package/lib/integrations/node.js

@@ -0,0 +1,9 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var integrationsManagerFactory = function integrationsManagerFactory() {};
+
+var _default = integrationsManagerFactory;
+exports.default = _default;

package/lib/integrations/package.json

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

package/lib/listeners/browser.js

@@ -0,0 +1,173 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _bulk = _interopRequireDefault(require("../services/events/bulk"));
+
+var _events = _interopRequireDefault(require("../services/events"));
+
+var _bulk2 = _interopRequireDefault(require("../services/impressions/bulk"));
+
+var _count = _interopRequireDefault(require("../services/impressions/count"));
+
+var _impressions = _interopRequireDefault(require("../services/impressions"));
+
+var _dto = require("../services/impressions/dto");
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _constants = require("../utils/constants");
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var log = (0, _logger.default)('splitio-client:cleanup'); // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+
+var UNLOAD_DOM_EVENT = 'unload';
+/**
+ * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
+ *
+ */
+
+var BrowserSignalListener = /*#__PURE__*/function () {
+  function BrowserSignalListener(context, syncManager) {
+    this.storage = context.get(context.constants.STORAGE);
+    this.settings = context.get(context.constants.SETTINGS);
+    this.syncManager = syncManager;
+    this.flushData = this.flushData.bind(this);
+
+    if (this.settings.sync.impressionsMode === _constants.OPTIMIZED) {
+      this.impressionsCounter = context.get(context.constants.IMPRESSIONS_COUNTER);
+    }
+  }
+  /**
+   * start method.
+   * Called when SplitFactory is initialized.
+   * We add a handler on unload events. The handler flushes remaining impressions and events to the backend.
+   */
+
+
+  var _proto = BrowserSignalListener.prototype;
+
+  _proto.start = function start() {
+    if (typeof window !== 'undefined' && window.addEventListener) {
+      log.debug('Registering flush handler when unload page event is triggered.');
+      window.addEventListener(UNLOAD_DOM_EVENT, this.flushData);
+    }
+  }
+  /**
+   * stop method.
+   * Called when client is destroyed.
+   * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
+   */
+  ;
+
+  _proto.stop = function stop() {
+    if (typeof window !== 'undefined' && window.removeEventListener) {
+      log.debug('Deregistering flush handler when unload page event is triggered.');
+      window.removeEventListener(UNLOAD_DOM_EVENT, this.flushData);
+    }
+  }
+  /**
+   * _flushData method.
+   * Called when unload event is triggered. It flushed remaining impressions and events to the backend,
+   * using beacon API if possible, or falling back to regular post transport.
+   */
+  ;
+
+  _proto.flushData = function flushData() {
+    this._flushImpressions();
+
+    this._flushEvents();
+
+    if (this.impressionsCounter) {
+      this._flushImpressionsCount();
+    } // Close streaming
+
+
+    if (this.syncManager && this.syncManager.pushManager) this.syncManager.pushManager.stop();
+  };
+
+  _proto._flushImpressions = function _flushImpressions() {
+    var impressions = this.storage.impressions; // if there are impressions in storage, send them to backend
+
+    if (!impressions.isEmpty()) {
+      var url = this.settings.url('/testImpressions/beacon');
+      var impressionsPayload = (0, _dto.fromImpressionsCollector)(impressions, this.settings);
+      var extraMetadata = {
+        // sim stands for Sync/Split Impressions Mode
+        sim: this.settings.sync.impressionsMode === _constants.OPTIMIZED ? _constants.OPTIMIZED : _constants.DEBUG
+      };
+
+      if (!this._sendBeacon(url, impressionsPayload, extraMetadata)) {
+        (0, _impressions.default)((0, _bulk2.default)(this.settings, {
+          body: JSON.stringify(impressionsPayload)
+        }));
+      }
+
+      impressions.clear();
+    }
+  };
+
+  _proto._flushImpressionsCount = function _flushImpressionsCount() {
+    var impressionsCountPayload = {
+      pf: (0, _dto.fromImpressionsCountCollector)(this.impressionsCounter)
+    };
+    var imprCounts = impressionsCountPayload.pf.length;
+    if (imprCounts === 0) return;
+    var url = this.settings.url('/testImpressions/count/beacon');
+
+    if (!this._sendBeacon(url, impressionsCountPayload)) {
+      (0, _impressions.default)((0, _count.default)(this.settings, {
+        body: JSON.stringify(impressionsCountPayload)
+      }));
+    }
+  };
+
+  _proto._flushEvents = function _flushEvents() {
+    var events = this.storage.events; // if there are events in storage, send them to backend
+
+    if (!events.isEmpty()) {
+      var url = this.settings.url('/events/beacon');
+      var eventsPayload = events.toJSON();
+
+      if (!this._sendBeacon(url, eventsPayload)) {
+        (0, _events.default)((0, _bulk.default)(this.settings, {
+          body: JSON.stringify(eventsPayload)
+        }));
+      }
+
+      events.clear();
+    }
+  }
+  /**
+   * _sendBeacon method.
+   * Util method that check if beacon API is available, build the payload and send it.
+   */
+  ;
+
+  _proto._sendBeacon = function _sendBeacon(url, data, extraMetadata) {
+    // eslint-disable-next-line compat/compat
+    if (typeof navigator !== 'undefined' && navigator.sendBeacon) {
+      var json = {
+        entries: data,
+        token: this.settings.core.authorizationKey,
+        sdk: this.settings.version
+      }; // Extend with endpoint specific metadata where needed
+
+      if (extraMetadata) (0, _objectAssign.default)(json, extraMetadata); // Stringify the payload
+
+      var payload = JSON.stringify(json); // eslint-disable-next-line compat/compat
+
+      return navigator.sendBeacon(url, payload);
+    }
+
+    return false;
+  };
+
+  return BrowserSignalListener;
+}();
+
+exports.default = BrowserSignalListener;

package/lib/listeners/node.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _thenable = _interopRequireDefault(require("../utils/promise/thenable"));
+
+var log = (0, _logger.default)('splitio-client:cleanup');
+/**
+ * We'll listen for SIGTERM since it's the standard signal for server shutdown.
+ *
+ * If you're stopping the execution yourself via the keyboard, or by calling process.exit,
+ * you should call the cleanup logic yourself, since we cannot ensure the data is sent after
+ * the process is already exiting.
+ */
+
+var NodeSignalListener = /*#__PURE__*/function () {
+  function NodeSignalListener() {
+    this._sigtermHandler = this._sigtermHandler.bind(this);
+  }
+
+  var _proto = NodeSignalListener.prototype;
+
+  _proto.start = function start(handler) {
+    this.handler = handler;
+    log.debug('Registering cleanup handlers.');
+    process.on('SIGTERM', this._sigtermHandler);
+  };
+
+  _proto.stop = function stop() {
+    log.debug('Deregistering cleanup handlers.');
+    process.removeListener('SIGTERM', this._sigtermHandler);
+  }
+  /**
+   * Call the handler, clean up listeners and emit the signal again.
+   */
+  ;
+
+  _proto._sigtermHandler = function _sigtermHandler() {
+    var _this = this;
+
+    var wrapUp = function wrapUp() {
+      // Cleaned up, remove handlers.
+      _this.stop(); // This handler prevented the default behaviour, start again.
+
+
+      process.kill(process.pid, 'SIGTERM');
+    };
+
+    log.debug('Split SDK graceful shutdown after SIGTERM.');
+    var handlerResult = null;
+
+    try {
+      handlerResult = this.handler();
+    } catch (err) {
+      log.error("Error with Split graceful shutdown: " + err);
+    }
+
+    if ((0, _thenable.default)(handlerResult)) {
+      // Always exit, even with errors. The promise is returned for UT purposses.
+      return handlerResult.then(wrapUp).catch(wrapUp);
+    } else {
+      wrapUp();
+    }
+  };
+
+  return NodeSignalListener;
+}();
+
+exports.default = NodeSignalListener;

package/lib/listeners/package.json

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

package/lib/manager/index.js

@@ -0,0 +1,115 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var _thenable = _interopRequireDefault(require("../utils/promise/thenable"));
+
+var _lang = require("../utils/lang");
+
+var _inputValidation = require("../utils/inputValidation");
+
+var collectTreatments = function collectTreatments(splitObject) {
+  var conditions = splitObject.conditions; // Rollout conditions are supposed to have the entire partitions list, so we find the first one.
+
+  var allTreatmentsCondition = (0, _lang.find)(conditions, function (cond) {
+    return cond.conditionType === 'ROLLOUT';
+  }); // Localstorage mode could fall into a no rollout conditions state. Take the first condition in that case.
+
+  if (!allTreatmentsCondition) allTreatmentsCondition = conditions[0]; // Then extract the treatments from the partitions
+
+  return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(function (v) {
+    return v.treatment;
+  }) : [];
+};
+
+var ObjectToView = function ObjectToView(json) {
+  var splitObject;
+
+  try {
+    splitObject = JSON.parse(json);
+  } catch (e) {
+    return null;
+  }
+
+  if (splitObject == null) return null;
+  return {
+    name: splitObject.name,
+    trafficType: splitObject.trafficTypeName || null,
+    killed: splitObject.killed,
+    changeNumber: splitObject.changeNumber || 0,
+    treatments: collectTreatments(splitObject),
+    configs: splitObject.configurations || {}
+  };
+};
+
+var ObjectsToViews = function ObjectsToViews(jsons) {
+  var views = [];
+  jsons.forEach(function (split) {
+    var view = ObjectToView(split);
+    if (view != null) views.push(view);
+  });
+  return views;
+};
+
+function SplitManagerFactory(_splits, context) {
+  var SPLIT_FN_LABEL = 'split';
+  var statusManager = context.get(context.constants.STATUS_MANAGER);
+  return (0, _objectAssign.default)( // Proto-linkage of the readiness Event Emitter
+  Object.create(statusManager), {
+    /**
+     * Get the Split object corresponding to the given split name if valid
+     */
+    split: function split(maybeSplitName) {
+      var splitName = (0, _inputValidation.validateSplit)(maybeSplitName, SPLIT_FN_LABEL);
+
+      if (!(0, _inputValidation.validateIfDestroyed)(context) || !(0, _inputValidation.validateIfReady)(context, SPLIT_FN_LABEL) || !splitName) {
+        return null;
+      }
+
+      var split = _splits.getSplit(splitName);
+
+      if ((0, _thenable.default)(split)) {
+        return split.then(function (result) {
+          (0, _inputValidation.validateSplitExistance)(context, splitName, result, SPLIT_FN_LABEL);
+          return ObjectToView(result);
+        });
+      }
+
+      (0, _inputValidation.validateSplitExistance)(context, splitName, split, SPLIT_FN_LABEL);
+      return ObjectToView(split);
+    },
+
+    /**
+     * Get the Split objects present on the factory storage
+     */
+    splits: function splits() {
+      if (!(0, _inputValidation.validateIfDestroyed)(context) || !(0, _inputValidation.validateIfReady)(context, 'splits')) {
+        return [];
+      }
+
+      var currentSplits = _splits.getAll();
+
+      if ((0, _thenable.default)(currentSplits)) return currentSplits.then(ObjectsToViews);
+      return ObjectsToViews(currentSplits);
+    },
+
+    /**
+     * Get the Split names present on the factory storage
+     */
+    names: function names() {
+      if (!(0, _inputValidation.validateIfDestroyed)(context) || !(0, _inputValidation.validateIfReady)(context, 'names')) {
+        return [];
+      }
+
+      return _splits.getKeys();
+    }
+  });
+}
+
+var _default = SplitManagerFactory;
+exports.default = _default;

package/lib/metrics/Collectors.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.ClientCollector = exports.MySegmentsCollector = exports.SplitChangesCollector = exports.SegmentChangesCollector = void 0;
+
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+
+var ProducerMetricsCollector = /*#__PURE__*/function () {
+  function ProducerMetricsCollector(storage) {
+    this.storage = storage;
+    this.latency = this.latency.bind(this);
+    this.count = this.count.bind(this);
+    this.countException = this.countException.bind(this);
+  }
+
+  var _proto = ProducerMetricsCollector.prototype;
+
+  _proto.latency = function latency(ms) {
+    this.storage.metrics.track(this.metricType + ".time", ms);
+  };
+
+  _proto.count = function count(status) {
+    this.storage.count.track(this.metricType + ".status." + status);
+  };
+
+  _proto.countException = function countException() {
+    this.storage.count.track(this.metricType + ".exception");
+  };
+
+  return ProducerMetricsCollector;
+}();
+
+var SegmentChangesCollector = /*#__PURE__*/function (_ProducerMetricsColle) {
+  (0, _inheritsLoose2.default)(SegmentChangesCollector, _ProducerMetricsColle);
+
+  function SegmentChangesCollector(storage) {
+    var _this;
+
+    _this = _ProducerMetricsColle.call(this, storage) || this;
+    _this.metricType = 'segmentChangeFetcher';
+    return _this;
+  }
+
+  return SegmentChangesCollector;
+}(ProducerMetricsCollector);
+
+exports.SegmentChangesCollector = SegmentChangesCollector;
+
+var SplitChangesCollector = /*#__PURE__*/function (_ProducerMetricsColle2) {
+  (0, _inheritsLoose2.default)(SplitChangesCollector, _ProducerMetricsColle2);
+
+  function SplitChangesCollector(storage) {
+    var _this2;
+
+    _this2 = _ProducerMetricsColle2.call(this, storage) || this;
+    _this2.metricType = 'splitChangeFetcher';
+    return _this2;
+  }
+
+  return SplitChangesCollector;
+}(ProducerMetricsCollector);
+
+exports.SplitChangesCollector = SplitChangesCollector;
+
+var MySegmentsCollector = /*#__PURE__*/function (_ProducerMetricsColle3) {
+  (0, _inheritsLoose2.default)(MySegmentsCollector, _ProducerMetricsColle3);
+
+  function MySegmentsCollector(storage) {
+    var _this3;
+
+    _this3 = _ProducerMetricsColle3.call(this, storage) || this;
+    _this3.metricType = 'mySegmentsFetcher';
+    return _this3;
+  }
+
+  return MySegmentsCollector;
+}(ProducerMetricsCollector);
+
+exports.MySegmentsCollector = MySegmentsCollector;
+
+var ClientCollector = /*#__PURE__*/function () {
+  function ClientCollector(storage) {
+    this.storage = storage;
+    this.ready = this.ready.bind(this);
+    this.getTreatment = this.getTreatment.bind(this);
+    this.getTreatments = this.getTreatments.bind(this);
+    this.getTreatmentWithConfig = this.getTreatmentWithConfig.bind(this);
+    this.getTreatmentsWithConfig = this.getTreatmentsWithConfig.bind(this);
+  }
+
+  var _proto2 = ClientCollector.prototype;
+
+  _proto2.ready = function ready(ms) {
+    this.storage.metrics.track('sdk.ready', ms);
+  };
+
+  _proto2.getTreatment = function getTreatment(ms) {
+    this.storage.metrics.track('sdk.getTreatment', ms);
+  };
+
+  _proto2.getTreatments = function getTreatments(ms) {
+    this.storage.metrics.track('sdk.getTreatments', ms);
+  };
+
+  _proto2.getTreatmentWithConfig = function getTreatmentWithConfig(ms) {
+    this.storage.metrics.track('sdk.getTreatmentWithConfig', ms);
+  };
+
+  _proto2.getTreatmentsWithConfig = function getTreatmentsWithConfig(ms) {
+    this.storage.metrics.track('sdk.getTreatmentsWithConfig', ms);
+  };
+
+  return ClientCollector;
+}();
+
+exports.ClientCollector = ClientCollector;