@splitsoftware/splitio 10.17.1 → 10.17.3-rc.1

package/src/integrations/ga/SplitToGa.js

@@ -1,125 +0,0 @@
-import logFactory from '../../utils/logger';
-import { uniq } from '../../utils/lang';
-import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../../utils/constants';
-const log = logFactory('splitio-split-to-ga');
-
-class SplitToGa {
-
-  // Default mapper function.
-  static defaultMapper({ type, payload }) {
-    switch (type) {
-      case 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 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.
-  static 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.
-   */
-  static 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;
-  }
-
-  constructor(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 = 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');
-  }
-
-  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.
-    const ga = SplitToGa.getGa();
-    if (ga) {
-
-      if(this.impressions === false && data.type === SPLIT_IMPRESSION) return;
-      if(this.events === false && data.type === SPLIT_EVENT) return;
-
-      let 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(trackerName => {
-        const 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);
-      });
-    }
-  }
-
-}
-
-// A falsy object represents the default tracker
-SplitToGa.defaultTrackerNames = [''];
-
-export default SplitToGa;

package/src/integrations/node.js

@@ -1,4 +0,0 @@
-const integrationsManagerFactory = () => {
-};
-
-export default integrationsManagerFactory;

package/src/integrations/package.json

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

package/src/listeners/browser.js

@@ -1,137 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

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

package/src/manager/index.js

@@ -1,103 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,174 +0,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.
-**/
-
-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;