@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/src/listeners/browser.js

@@ -0,0 +1,137 @@
+import eventsBulkRequest from '../services/events/bulk';
+import eventsService from '../services/events';
+import impressionsBulkRequest from '../services/impressions/bulk';
+import impressionsCountRequest from '../services/impressions/count';
+import impressionsService from '../services/impressions';
+import { fromImpressionsCollector, fromImpressionsCountCollector } from '../services/impressions/dto';
+import logFactory from '../utils/logger';
+import { OPTIMIZED, DEBUG } from '../utils/constants';
+import objectAssign from 'object-assign';
+
+const log = logFactory('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.
+const 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.
+ *
+ */
+export default class BrowserSignalListener {
+
+  constructor(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 === 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.
+   */
+  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.
+   */
+  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.
+   */
+  flushData() {
+    this._flushImpressions();
+    this._flushEvents();
+    if (this.impressionsCounter) {
+      this._flushImpressionsCount();
+    }
+    // Close streaming
+    if (this.syncManager && this.syncManager.pushManager) this.syncManager.pushManager.stop();
+  }
+
+  _flushImpressions() {
+    const impressions = this.storage.impressions;
+    // if there are impressions in storage, send them to backend
+    if (!impressions.isEmpty()) {
+      const url = this.settings.url('/testImpressions/beacon');
+      const impressionsPayload = fromImpressionsCollector(impressions, this.settings);
+      const extraMetadata = {
+        // sim stands for Sync/Split Impressions Mode
+        sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
+      };
+
+      if (!this._sendBeacon(url, impressionsPayload, extraMetadata)) {
+        impressionsService(impressionsBulkRequest(this.settings, { body: JSON.stringify(impressionsPayload) }));
+      }
+      impressions.clear();
+    }
+  }
+
+  _flushImpressionsCount() {
+    const impressionsCountPayload = { pf: fromImpressionsCountCollector(this.impressionsCounter) };
+    const imprCounts = impressionsCountPayload.pf.length;
+    if (imprCounts === 0) return;
+    const url = this.settings.url('/testImpressions/count/beacon');
+    if (!this._sendBeacon(url, impressionsCountPayload)) {
+      impressionsService(impressionsCountRequest(this.settings, { body: JSON.stringify(impressionsCountPayload) }));
+    }
+  }
+
+  _flushEvents() {
+    const events = this.storage.events;
+    // if there are events in storage, send them to backend
+    if (!events.isEmpty()) {
+      const url = this.settings.url('/events/beacon');
+      const eventsPayload = events.toJSON();
+      if (!this._sendBeacon(url, eventsPayload)) {
+        eventsService(eventsBulkRequest(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.
+   */
+  _sendBeacon(url, data, extraMetadata) {
+    // eslint-disable-next-line compat/compat
+    if (typeof navigator !== 'undefined' && navigator.sendBeacon) {
+      const json = {
+        entries: data,
+        token: this.settings.core.authorizationKey,
+        sdk: this.settings.version,
+      };
+
+      // Extend with endpoint specific metadata where needed
+      if (extraMetadata) objectAssign(json, extraMetadata);
+
+      // Stringify the payload
+      const payload = JSON.stringify(json);
+
+      // eslint-disable-next-line compat/compat
+      return navigator.sendBeacon(url, payload);
+    }
+    return false;
+  }
+}

package/src/listeners/node.js

@@ -0,0 +1,59 @@
+import logFactory from '../utils/logger';
+import thenable from '../utils/promise/thenable';
+const log = logFactory('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.
+ */
+export default class NodeSignalListener {
+  constructor() {
+    this._sigtermHandler = this._sigtermHandler.bind(this);
+  }
+
+  start(handler) {
+    this.handler = handler;
+
+    log.debug('Registering cleanup handlers.');
+    process.on('SIGTERM', this._sigtermHandler);
+  }
+
+  stop() {
+    log.debug('Deregistering cleanup handlers.');
+    process.removeListener('SIGTERM', this._sigtermHandler);
+  }
+
+  /**
+   * Call the handler, clean up listeners and emit the signal again.
+   */
+  _sigtermHandler() {
+    const 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.');
+
+    let handlerResult = null;
+
+    try {
+      handlerResult = this.handler();
+    } catch (err) {
+      log.error(`Error with Split graceful shutdown: ${err}`);
+    }
+
+    if (thenable(handlerResult)) {
+      // Always exit, even with errors. The promise is returned for UT purposses.
+      return handlerResult.then(wrapUp).catch(wrapUp);
+    } else {
+      wrapUp();
+    }
+  }
+}
+

package/src/listeners/package.json

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

package/src/manager/index.js

@@ -0,0 +1,103 @@
+import objectAssign from 'object-assign';
+import thenable from '../utils/promise/thenable';
+import { find } from '../utils/lang';
+import { validateSplit, validateSplitExistance, validateIfDestroyed, validateIfReady } from '../utils/inputValidation';
+
+const collectTreatments = (splitObject) => {
+  const conditions = splitObject.conditions;
+  // Rollout conditions are supposed to have the entire partitions list, so we find the first one.
+  let allTreatmentsCondition = find(conditions, (cond) => 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(v => v.treatment) : [];
+};
+
+const ObjectToView = (json) => {
+  let 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 || {}
+  };
+};
+
+const ObjectsToViews = (jsons) => {
+  let views = [];
+
+  jsons.forEach(split => {
+    const view = ObjectToView(split);
+    if (view != null) views.push(view);
+  });
+
+  return views;
+};
+
+function SplitManagerFactory(splits, context) {
+  const SPLIT_FN_LABEL = 'split';
+  const statusManager = context.get(context.constants.STATUS_MANAGER);
+
+  return objectAssign(
+    // Proto-linkage of the readiness Event Emitter
+    Object.create(statusManager),
+    {
+      /**
+       * Get the Split object corresponding to the given split name if valid
+       */
+      split(maybeSplitName) {
+        const splitName = validateSplit(maybeSplitName, SPLIT_FN_LABEL);
+        if (!validateIfDestroyed(context) || !validateIfReady(context, SPLIT_FN_LABEL) || !splitName) {
+          return null;
+        }
+
+        const split = splits.getSplit(splitName);
+
+        if (thenable(split)) {
+          return split.then(result => {
+            validateSplitExistance(context, splitName, result, SPLIT_FN_LABEL);
+            return ObjectToView(result);
+          });
+        }
+
+        validateSplitExistance(context, splitName, split, SPLIT_FN_LABEL);
+
+        return ObjectToView(split);
+      },
+      /**
+       * Get the Split objects present on the factory storage
+       */
+      splits() {
+        if (!validateIfDestroyed(context) || !validateIfReady(context, 'splits')) {
+          return [];
+        }
+        const currentSplits = splits.getAll();
+
+        if (thenable(currentSplits)) return currentSplits.then(ObjectsToViews);
+        return ObjectsToViews(currentSplits);
+      },
+      /**
+       * Get the Split names present on the factory storage
+       */
+      names() {
+        if (!validateIfDestroyed(context) || !validateIfReady(context, 'names')) {
+          return [];
+        }
+        return splits.getKeys();
+      }
+    }
+  );
+}
+
+export default SplitManagerFactory;

package/src/metrics/Collectors.js

@@ -0,0 +1,77 @@
+class ProducerMetricsCollector {
+  constructor(storage) {
+    this.storage = storage;
+
+    this.latency = this.latency.bind(this);
+    this.count = this.count.bind(this);
+    this.countException = this.countException.bind(this);
+  }
+
+  latency(ms) {
+    this.storage.metrics.track(`${this.metricType}.time`, ms);
+  }
+
+  count(status) {
+    this.storage.count.track(`${this.metricType}.status.${status}`);
+  }
+
+  countException() {
+    this.storage.count.track(`${this.metricType}.exception`);
+  }
+}
+
+export class SegmentChangesCollector extends ProducerMetricsCollector {
+  constructor(storage) {
+    super(storage);
+
+    this.metricType = 'segmentChangeFetcher';
+  }
+}
+
+export class SplitChangesCollector extends ProducerMetricsCollector {
+  constructor(storage) {
+    super(storage);
+
+    this.metricType = 'splitChangeFetcher';
+  }
+}
+
+export class MySegmentsCollector extends ProducerMetricsCollector {
+  constructor(storage) {
+    super(storage);
+
+    this.metricType = 'mySegmentsFetcher';
+  }
+}
+
+export class ClientCollector {
+  constructor(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);
+  }
+
+  ready(ms) {
+    this.storage.metrics.track('sdk.ready', ms);
+  }
+
+  getTreatment(ms) {
+    this.storage.metrics.track('sdk.getTreatment', ms);
+  }
+
+  getTreatments(ms) {
+    this.storage.metrics.track('sdk.getTreatments', ms);
+  }
+
+  getTreatmentWithConfig(ms) {
+    this.storage.metrics.track('sdk.getTreatmentWithConfig', ms);
+  }
+
+  getTreatmentsWithConfig(ms) {
+    this.storage.metrics.track('sdk.getTreatmentsWithConfig', ms);
+  }
+}

package/src/metrics/index.js

@@ -0,0 +1,174 @@
+/**
+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.
+**/
+
+import logFactory from '../utils/logger';
+import tracker from '../utils/timeTracker';
+import repeat from '../utils/fn/repeat';
+import metricsService from '../services/metrics';
+import metricsTimesServiceRequest from '../services/metrics/times';
+import metricsCountersServiceRequest from '../services/metrics/counters';
+import {
+  fromLatenciesCollector,
+  fromCountersCollector
+} from '../services/metrics/dto';
+import impressionsService from '../services/impressions';
+import impressionsBulkRequest from '../services/impressions/bulk';
+import impressionsCountRequest from '../services/impressions/count';
+import { fromImpressionsCollector, fromImpressionsCountCollector } from '../services/impressions/dto';
+import {
+  SegmentChangesCollector,
+  SplitChangesCollector,
+  MySegmentsCollector,
+  ClientCollector
+} from './Collectors';
+import { OPTIMIZED } from '../utils/constants';
+
+const log = logFactory('splitio-metrics');
+const IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
+
+const MetricsFactory = context => {
+  let impressionsRetries = 0;
+  const settings = context.get(context.constants.SETTINGS);
+  const storage = context.get(context.constants.STORAGE);
+  const impressionsCounter = context.get(context.constants.IMPRESSIONS_COUNTER);
+  const shouldPushImpressionsCount = settings.sync.impressionsMode === OPTIMIZED;
+
+  const pushMetrics = () => {
+    if (storage.metrics.isEmpty() && storage.count.isEmpty()) return Promise.resolve();
+
+    log.debug('Pushing metrics');
+    const latencyTrackerStop = tracker.start(tracker.TaskNames.METRICS_PUSH);
+
+    // POST latencies
+    const latenciesPromise = storage.metrics.isEmpty() ? null : metricsService(
+      metricsTimesServiceRequest(settings, {
+        body: JSON.stringify(fromLatenciesCollector(storage.metrics))
+      }))
+      .then(() => storage.metrics.clear())
+      .catch(() => storage.metrics.clear());
+
+    // POST counters
+    const countersPromise = storage.count.isEmpty() ? null : metricsService(
+      metricsCountersServiceRequest(settings, {
+        body: JSON.stringify(fromCountersCollector(storage.count))
+      }))
+      .then(() => storage.count.clear())
+      .catch(() => storage.count.clear());
+
+    return Promise.all([latenciesPromise, countersPromise]).then(resp => {
+      // After both finishes, track the end and return the results
+      latencyTrackerStop();
+      return resp;
+    });
+  };
+
+  const pushImpressions = () => {
+    if (storage.impressions.isEmpty()) return Promise.resolve();
+    const imprCount = storage.impressions.queue.length;
+
+    log.info(`Pushing ${imprCount} impressions`);
+    const latencyTrackerStop = tracker.start(tracker.TaskNames.IMPRESSIONS_PUSH);
+
+    return impressionsService(impressionsBulkRequest(settings, {
+      body: JSON.stringify(fromImpressionsCollector(storage.impressions, settings))
+    }))
+      .then(() => {
+        impressionsRetries = 0;
+        storage.impressions.clear();
+      })
+      .catch(err => {
+        if (impressionsRetries) { // For now we retry only once.
+          log.warn(`Droping ${imprCount} impressions after retry. Reason ${err}.`);
+          impressionsRetries = 0;
+          storage.impressions.clear();
+        } else {
+          impressionsRetries++;
+          log.warn(`Failed to push ${imprCount} impressions, keeping data to retry on next iteration. Reason ${err}.`);
+        }
+      })
+      .then(() => latencyTrackerStop());
+  };
+
+  const pushImpressionsCount = () => {
+    const pf = fromImpressionsCountCollector(impressionsCounter);
+    const imprCounts = pf.length;
+    if (imprCounts === 0) return Promise.resolve();
+
+    log.info(`Pushing count of impressions for ${imprCounts} features`);
+
+    return impressionsService(impressionsCountRequest(settings, {
+      body: JSON.stringify({ pf })
+    }))
+      .then(() => {
+        impressionsRetries = 0;
+      })
+      .catch(err => {
+        if (impressionsRetries) { // For now we retry only once.
+          log.warn(`Droping count of impressions for ${imprCounts} features after retry. Reason ${err}.`);
+          impressionsRetries = 0;
+        } else {
+          impressionsRetries++;
+          log.warn(`Failed to push impressions count for ${imprCounts} features, keeping data to retry on next iteration. Reason ${err}.`);
+        }
+      });
+  };
+
+  let stopImpressionsPublisher = false;
+  let stopPerformancePublisher = false;
+  let stopImpressionsCountPublisher = false;
+
+  return {
+    start() {
+      stopImpressionsPublisher = repeat(
+        schedulePublisher => pushImpressions().then(() => schedulePublisher()),
+        settings.scheduler.impressionsRefreshRate
+      );
+
+      stopPerformancePublisher = repeat(
+        schedulePublisher => pushMetrics().then(() => schedulePublisher()),
+        settings.scheduler.metricsRefreshRate
+      );
+
+      if (shouldPushImpressionsCount) {
+        stopImpressionsCountPublisher = repeat(
+          schedulePublisher => pushImpressionsCount().then(() => schedulePublisher()),
+          IMPRESSIONS_COUNT_RATE
+        );
+      }
+    },
+
+    flush() {
+      if (shouldPushImpressionsCount) pushImpressionsCount();
+      return pushImpressions();
+    },
+
+    stop() {
+      stopImpressionsPublisher && stopImpressionsPublisher();
+      stopPerformancePublisher && stopPerformancePublisher();
+      stopImpressionsCountPublisher && stopImpressionsCountPublisher();
+    },
+
+    // Metrics collectors
+    collectors: {
+      segmentChanges: new SegmentChangesCollector(storage),
+      splitChanges: new SplitChangesCollector(storage),
+      mySegments: new MySegmentsCollector(storage),
+      client: new ClientCollector(storage)
+    }
+  };
+};
+
+export default MetricsFactory;

package/src/producer/browser/Partial.js

@@ -0,0 +1,104 @@
+/**
+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.
+**/
+
+import TaskFactory from '../task';
+import MySegmentsUpdater from '../updater/MySegments';
+import logFactory from '../../utils/logger';
+const log = logFactory('splitio-producer:mySegmentsHandler');
+
+/**
+ * Incremental updater to be used to share data in the browser.
+ */
+const PartialBrowserProducer = (context) => {
+  const settings = context.get(context.constants.SETTINGS);
+  const splitsStorage = context.get(context.constants.STORAGE).splits;
+  const { splits: splitsEventEmitter, segments: segmentsEventEmitter } = context.get(context.constants.READINESS);
+
+  const mySegmentsUpdater = MySegmentsUpdater(context);
+  const mySegmentsUpdaterTask = TaskFactory(synchronizeMySegments, settings.scheduler.segmentsRefreshRate);
+
+  splitsEventEmitter.on(splitsEventEmitter.SDK_SPLITS_ARRIVED, smartPausing);
+  // needed for shared clients, we run `smartReady` a first time if splits were sync and don't use segments,
+  // to emit SDK_SEGMENTS_ARRIVED (and thus SDK_READY) immediately in next event cycle
+  if (!splitsStorage.usesSegments()) setTimeout(smartReady, 0);
+  else splitsEventEmitter.once(splitsEventEmitter.SDK_SPLITS_ARRIVED, smartReady);
+
+  let isSynchronizingMySegments = false;
+
+  /**
+   * @param {string[] | undefined} segmentList might be undefined
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+  function synchronizeMySegments(segmentList, noCache) {
+    isSynchronizingMySegments = true;
+    // `mySegmentsUpdater` promise always resolves, and with a false value if it fails to fetch or store mySegments
+    return mySegmentsUpdater(0, segmentList, noCache).then(function (res) {
+      isSynchronizingMySegments = false;
+      return res;
+    });
+  }
+
+  let running = false;
+  // we cannot rely on `mySegmentsUpdaterTask.isRunning` to check if doing polling
+  function isRunning() {
+    return running;
+  }
+
+  // emit SDK_SEGMENTS_ARRIVED (and thus SDK_READY) if not ready yet and splits are not using segments
+  function smartReady() {
+    const isReady = context.get(context.constants.READY, true);
+    if (!isReady && !splitsStorage.usesSegments()) segmentsEventEmitter.emit(segmentsEventEmitter.SDK_SEGMENTS_ARRIVED);
+  }
+
+  // smartly pause/resume mySegmentsUpdaterTask while doing polling
+  function smartPausing() {
+    if (!running) return; // noop if not doing polling
+    const splitsHaveSegments = splitsStorage.usesSegments();
+    if (splitsHaveSegments !== mySegmentsUpdaterTask.isRunning()) {
+      log.info(`Turning segments data polling ${splitsHaveSegments ? 'ON' : 'OFF'}.`);
+      if (splitsHaveSegments) {
+        mySegmentsUpdaterTask.start();
+      } else {
+        mySegmentsUpdaterTask.stop();
+      }
+    }
+  }
+
+  return {
+    // Start periodic fetching (polling)
+    start() {
+      running = true;
+      if (splitsStorage.usesSegments()) mySegmentsUpdaterTask.start();
+    },
+
+    // Stop periodic fetching (polling)
+    stop() {
+      running = false;
+      mySegmentsUpdaterTask.stop();
+    },
+
+    // Used by SyncManager to know if running in polling mode.
+    isRunning,
+
+    // Used by MySegmentUpdateWorker
+    isSynchronizingMySegments() {
+      return isSynchronizingMySegments;
+    },
+    synchronizeMySegments,
+  };
+};
+
+export default PartialBrowserProducer;