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

package/src/engine/transforms/whitelist.js

@@ -1,22 +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 { _Set } from '../../utils/lang/Sets';
-
-function transform(whitelistObject) {
-  return new _Set(whitelistObject.whitelist);
-}
-
-export default transform;

package/src/engine/treatments/index.js

@@ -1,67 +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 { findIndex } from '../../utils/lang';
-
-function Treatments(ranges, treatments) {
-  if (!(this instanceof Treatments)) {
-    return new Treatments(ranges, treatments);
-  }
-
-  if (ranges[ranges.length - 1] !== 100) {
-    throw new RangeError('Provided invalid dataset as input');
-  }
-
-  this._ranges = ranges;
-  this._treatments = treatments;
-}
-
-Treatments.parse = function parse(data) {
-  let {ranges, treatments} = data.reduce((accum, value) => {
-    let {size, treatment} = value;
-
-    accum.ranges.push(accum.inc += size);
-    accum.treatments.push(treatment);
-
-    return accum;
-  }, {
-    inc: 0,
-    ranges: [],
-    treatments: []
-  });
-
-  return new Treatments(ranges, treatments);
-};
-
-Treatments.prototype.getTreatmentFor = function getTreatmentFor(x) {
-  if (x < 0 || x > 100) {
-    throw new RangeError('Please provide a value between 0 and 100');
-  }
-
-  // Readme [1]
-  // We need to manually add any dependency which escape of dummy resolution
-  // I'll deal with this in a future release
-  // for (let [k, r] of this._ranges.entries()) {
-  //   if (x <= r) return this._treatments[k];
-  // }
-
-  const index = findIndex(this._ranges, range => x <= range);
-  const treatment = this._treatments[index];
-
-  return treatment;
-};
-
-export default Treatments;

package/src/engine/value/index.js

@@ -1,53 +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';
-const log = logFactory('splitio-engine:value');
-import sanitizeValue from './sanitize';
-
-function parseValue(key, attributeName, attributes) {
-  let value = undefined;
-  if (attributeName) {
-    if (attributes) {
-      value = attributes[attributeName];
-      log.debug(`Extracted attribute [${attributeName}], [${value}] will be used for matching.`);
-    } else {
-      log.warn(`Defined attribute [${attributeName}], no attributes received.`);
-    }
-  } else {
-    value = key;
-  }
-
-  return value;
-}
-
-/**
- * Defines value to be matched (key / attribute).
- */
-function value(key, matcherDto, attributes) {
-  const attributeName = matcherDto.attribute;
-  const valueToMatch = parseValue(key, attributeName, attributes);
-  const sanitizedValue = sanitizeValue(matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
-
-  if (sanitizedValue !== undefined) {
-    return sanitizedValue;
-  } else {
-    log.warn(`Value ${valueToMatch} ${attributeName ? `for attribute ${attributeName} ` : + ''}doesn't match with expected type.`);
-    return;
-  }
-}
-
-export default value;

package/src/engine/value/sanitize.js

@@ -1,117 +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';
-const log = logFactory('splitio-engine:sanitize');
-import { isObject, uniq, toString, toNumber } from '../../utils/lang';
-import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import { matcherTypes, matcherDataTypes } from '../matchers/types';
-
-function sanitizeNumber(val) {
-  const num = toNumber(val);
-  return isNaN(num) ? undefined : num;
-}
-
-function sanitizeString(val) {
-  let valueToSanitize = val;
-
-  if (isObject(val)) {
-    // If the value is an object and is not a key, discard it.
-    valueToSanitize = val.matchingKey ? val.matchingKey : undefined;
-  }
-
-  const str = toString(valueToSanitize);
-  return str ? str : undefined;
-}
-
-function sanitizeArray(val) {
-  const arr = Array.isArray(val) ? uniq(val.map(e => e + '')) : [];
-  return arr.length ? arr : undefined;
-}
-
-function sanitizeBoolean(val) {
-  if (val === true || val === false) return val;
-
-  if (typeof val === 'string') {
-    const lowerCaseValue = val.toLocaleLowerCase();
-
-    if (lowerCaseValue === 'true') return true;
-    if (lowerCaseValue === 'false') return false;
-  }
-
-  return undefined;
-}
-
-function dependencyProcessor(sanitizedValue, attributes) {
-  return {
-    key: sanitizedValue,
-    attributes
-  };
-}
-
-/**
- * We can define a pre-processing for the value, to be executed prior to matcher evaluation.
- */
-function getProcessingFunction(matcherTypeID, dataType) {
-  switch (matcherTypeID) {
-    case matcherTypes.EQUAL_TO:
-      return dataType === 'DATETIME' ? zeroSinceHH : undefined;
-    case matcherTypes.GREATER_THAN_OR_EQUAL_TO:
-    case matcherTypes.LESS_THAN_OR_EQUAL_TO:
-    case matcherTypes.BETWEEN:
-      return dataType === 'DATETIME' ? zeroSinceSS : undefined;
-    case matcherTypes.IN_SPLIT_TREATMENT:
-      return dependencyProcessor;
-    default:
-      return undefined;
-  }
-}
-
-function sanitizeValue(matcherTypeID, value, dataType, attributes) {
-  const processor = getProcessingFunction(matcherTypeID, dataType);
-  let sanitizedValue;
-
-  switch (dataType) {
-    case matcherDataTypes.NUMBER:
-    case matcherDataTypes.DATETIME:
-      sanitizedValue = sanitizeNumber(value);
-      break;
-    case matcherDataTypes.STRING:
-      sanitizedValue = sanitizeString(value);
-      break;
-    case matcherDataTypes.SET:
-      sanitizedValue = sanitizeArray(value);
-      break;
-    case matcherDataTypes.BOOLEAN:
-      sanitizedValue = sanitizeBoolean(value);
-      break;
-    case matcherDataTypes.NOT_SPECIFIED:
-      sanitizedValue = value;
-      break;
-    default:
-      sanitizedValue = undefined;
-  }
-
-  if (processor) {
-    sanitizedValue = processor(sanitizedValue, attributes);
-  }
-
-  log.debug(`Attempted to sanitize [${value}] which should be of type [${dataType}]. \n Sanitized and processed value => [${sanitizedValue instanceof Object ? JSON.stringify(sanitizedValue) : sanitizedValue}]`);
-
-  return sanitizedValue;
-}
-
-export default sanitizeValue;

package/src/events/index.js

@@ -1,62 +0,0 @@
-import logFactory from '../utils/logger';
-const log = logFactory('splitio-events');
-import tracker from '../utils/timeTracker';
-import repeat from '../utils/fn/repeat';
-import eventsService from '../services/events';
-import eventsBulkRequest from '../services/events/bulk';
-
-const EventsFactory = context => {
-  const settings = context.get(context.constants.SETTINGS);
-  const storage = context.get(context.constants.STORAGE);
-
-  const pushEvents = () => {
-    if (storage.events.isEmpty()) return Promise.resolve();
-
-    log.info(`Pushing ${storage.events.state().length} queued events.`);
-    const latencyTrackerStop = tracker.start(tracker.TaskNames.EVENTS_PUSH);
-    const json = JSON.stringify(storage.events.toJSON());
-    const wrapUpCb = () => latencyTrackerStop();
-    storage.events.clear(); // we always clear the queue.
-
-    return eventsService(eventsBulkRequest(settings, {
-      body: json
-    })).then(wrapUpCb).catch(wrapUpCb);
-  };
-
-  let stopEventPublisherTimeout = false;
-  let stopEventsPublisher = false;
-  const startEventsPublisher = () =>
-    stopEventsPublisher = repeat(
-      schedulePublisher => pushEvents().then(() => schedulePublisher()),
-      settings.scheduler.eventsPushRate
-    );
-
-  return {
-    start() {
-      // On the browser there may be a wish to wait an specific amount of seconds before the first push.
-      if (settings.startup.eventsFirstPushWindow > 0) {
-        stopEventPublisherTimeout = setTimeout(startEventsPublisher, settings.startup.eventsFirstPushWindow);
-      } else {
-        startEventsPublisher();
-      }
-    },
-
-    flush() {
-      return pushEvents();
-    },
-
-    stop() {
-      stopEventPublisherTimeout && clearTimeout(stopEventPublisherTimeout);
-      stopEventsPublisher && stopEventsPublisher();
-    },
-
-    flushAndResetTimer() {
-      // Reset the timer and push the events.
-      log.info('Flushing events and reseting timer.');
-      stopEventsPublisher && stopEventsPublisher.reset();
-      return pushEvents();
-    }
-  };
-};
-
-export default EventsFactory;

package/src/factory/offline.js

@@ -1,60 +0,0 @@
-import objectAssign from 'object-assign';
-import ClientFactory from '../client';
-import OfflineProducerFactory from '../producer/offline';
-import { releaseApiKey } from '../utils/inputValidation';
-
-//
-// Create SDK instance for offline mode.
-//
-function SplitFactoryOffline(context, sharedTrackers) {
-  const sharedInstance = !sharedTrackers;
-  const readiness = context.get(context.constants.READINESS);
-  const storage = context.get(context.constants.STORAGE);
-  const statusManager = context.get(context.constants.STATUS_MANAGER);
-
-  // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
-  // and then updated on each SDK_SPLITS_ARRIVED event
-  if (sharedInstance) setTimeout(() => {
-    readiness.splits.on(readiness.splits.SDK_SPLITS_ARRIVED, () => {
-      readiness.gate.emit(readiness.gate.SDK_UPDATE);
-    });
-    readiness.gate.emit(readiness.gate.SDK_READY);
-  }, 0);
-
-  // Producer
-  const producer = sharedInstance ? undefined : OfflineProducerFactory(context);
-
-  // Start background task for flag updates
-  producer && producer.start();
-
-  const api = objectAssign(
-    // Proto linkage of the EventEmitter to prevent any change
-    Object.create(statusManager),
-    // GetTreatment/s
-    ClientFactory(context),
-    // Utilities
-    {
-      // Destroy instance. Async so we respect the online api.
-      destroy() {
-        // Stop background jobs
-        producer && producer.stop();
-        // Cleanup event listeners
-        readiness.destroy();
-        // Cleanup storage
-        storage.destroy && storage.destroy();
-        // Mark the factory as destroyed.
-        context.put(context.constants.DESTROYED, true);
-        !sharedInstance && releaseApiKey();
-
-        return Promise.resolve();
-      }
-    }
-  );
-
-  return {
-    api,
-    metricCollectors: false // We won't collect any metrics on localhost mode.
-  };
-}
-
-export default SplitFactoryOffline;

package/src/factory/online.js

@@ -1,127 +0,0 @@
-import objectAssign from 'object-assign';
-import ClientFactory from '../client';
-import MetricsFactory from '../metrics';
-import EventsFactory from '../events';
-import SyncManagerFactory from '../sync';
-import SignalsListener from '../listeners';
-import { releaseApiKey } from '../utils/inputValidation';
-import { STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE } from '../utils/constants';
-
-// map of authorizationKeys to syncManagers, to keep a single instance per factory and needed to create shared clients
-const syncManagers = {};
-
-//
-// Create SDK instance based on the provided configurations
-//
-function SplitFactoryOnline(context, readyTrackers, mainClientMetricCollectors) {
-  const sharedInstance = !!mainClientMetricCollectors;
-  const settings = context.get(context.constants.SETTINGS);
-  const readiness = context.get(context.constants.READINESS);
-  const storage = context.get(context.constants.STORAGE);
-  const statusManager = context.get(context.constants.STATUS_MANAGER);
-
-  // We are only interested in exposable EventEmitter
-  const { gate, splits, segments } = readiness;
-
-  // Events name
-  const { SDK_READY } = gate;
-
-  // Shared instances use parent metrics collectors
-  const metrics = sharedInstance ? undefined : MetricsFactory(context);
-  // Shared instances use parent events queue
-  const events = sharedInstance ? undefined : EventsFactory(context);
-
-  let syncManager;
-
-  switch (settings.mode) {
-    case PRODUCER_MODE:
-    case STANDALONE_MODE: {
-      context.put(context.constants.COLLECTORS, metrics && metrics.collectors);
-      // We don't fully instantiate syncManager if we are creating a shared instance.
-      if (sharedInstance) {
-        syncManager = syncManagers[settings.core.authorizationKey].shared(context);
-      } else {
-        syncManager = SyncManagerFactory(context);
-        syncManagers[settings.core.authorizationKey] = syncManager;
-      }
-      break;
-    }
-    case CONSUMER_MODE: {
-      context.put(context.constants.READY_FROM_CACHE, true); // For SDK inner workings it's supposed to be ready from cache.
-      break;
-    }
-  }
-
-  // Signal listener only needed for main instances
-  const signalsListener = sharedInstance ? undefined : new SignalsListener(context, syncManager);
-
-  if (readyTrackers && syncManager && !sharedInstance) { // Only track ready events for non-shared and non-consumer clients
-    const {
-      sdkReadyTracker, splitsReadyTracker, segmentsReadyTracker
-    } = readyTrackers;
-
-    // Defered setup of collectors for this task, as it is the only ready latency we store on BE.
-    sdkReadyTracker.setCollectorForTask(metrics.collectors);
-
-    gate.once(SDK_READY, sdkReadyTracker);
-    splits.once(splits.SDK_SPLITS_ARRIVED, splitsReadyTracker);
-    segments.once(segments.SDK_SEGMENTS_ARRIVED, segmentsReadyTracker);
-  }
-
-  // Start background jobs tasks
-  syncManager && syncManager.start();
-  metrics && metrics.start();
-  events && context.put(context.constants.EVENTS, events) && events.start();
-
-  // If no collectors are stored we are on a shared instance, save main one.
-  context.put(context.constants.COLLECTORS, mainClientMetricCollectors);
-
-  const api = objectAssign(
-    // Proto linkage of the EventEmitter to prevent any change
-    Object.create(statusManager),
-    // getTreatment/s & track
-    ClientFactory(context),
-    // Utilities
-    {
-      // Destroy instance
-      destroy() {
-        // Stop background jobs
-        syncManager && syncManager.stop();
-        metrics && metrics.stop();
-        events && events.stop();
-
-        // Send impressions and events in parallel.
-        return Promise.all([
-          metrics && metrics.flush(),
-          events && events.flush()
-        ]).then(function () {
-
-          // Cleanup event listeners
-          readiness.destroy();
-          signalsListener && signalsListener.stop();
-
-          // Cleanup storage
-          storage.destroy && storage.destroy();
-          // Mark the factory as destroyed.
-          context.put(context.constants.DESTROYED, true);
-          // And release the API Key and SyncManager
-          if (!sharedInstance) {
-            releaseApiKey(settings.core.authorizationKey);
-            delete syncManagers[settings.core.authorizationKey];
-          }
-        });
-      }
-    }
-  );
-
-  // We'll start the signals listener if the client is not a shared instance.
-  // For now, we will only call destroy.
-  !sharedInstance && signalsListener.start(api.destroy);
-
-  return {
-    api,
-    metricCollectors: metrics && metrics.collectors
-  };
-}
-
-export default SplitFactoryOnline;

package/src/impressions/counter.js

@@ -1,43 +0,0 @@
-import { truncateTimeFrame } from '../utils/time';
-import objectAssign from 'object-assign';
-
-class ImpressionCounter {
-  constructor() {
-    this.cache = {};
-  }
-
-  /**
-  * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
-  */
-  _makeKey(featureName, timeFrame) {
-    return `${featureName}::${truncateTimeFrame(timeFrame)}`;
-  }
-
-  /**
-  * Increments the quantity of impressions with the passed featureName and timeFrame.
-  */
-  inc(featureName, timeFrame, amount) {
-    const key = this._makeKey(featureName, timeFrame);
-    const currentAmount = this.cache[key];
-    this.cache[key] = currentAmount ? currentAmount + amount : amount;
-  }
-
-  /**
-  * Returns all the elements stored in the cache and resets the cache.
-  */
-  popAll() {
-    const res = {};
-    objectAssign(res, this.cache);
-    this.cache = {};
-    return res;
-  }
-
-  /**
-  * Returns how many keys are stored in cache.
-  */
-  size() {
-    return Object.keys(this.cache).length;
-  }
-}
-
-export default ImpressionCounter;

package/src/impressions/hasher/buildKey.js

@@ -1,3 +0,0 @@
-export function buildKey(impression) {
-  return `${impression.keyName}:${impression.feature}:${impression.treatment}:${impression.label}:${impression.changeNumber}`;
-}

package/src/impressions/hasher/hashImpression128.js

@@ -1,6 +0,0 @@
-import { hash128 } from '../../engine/engine/murmur3/murmur3_128_x86';
-import { buildKey } from './buildKey';
-
-export function hashImpression128(impression) {
-  return hash128(buildKey(impression));
-}

package/src/impressions/hasher/hashImpression32.js

@@ -1,6 +0,0 @@
-import murmur from '../../engine/engine/murmur3/murmur3';
-import { buildKey } from './buildKey';
-
-export function hashImpression32(impression) {
-  return murmur.hash(buildKey(impression));
-}

package/src/impressions/observer/browser.js

@@ -1,8 +0,0 @@
-import ImpressionObserver from './observer';
-import { hashImpression32 } from '../hasher/hashImpression32';
-
-const LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes
-
-const BrowserImpressionObserverFactory = () => new ImpressionObserver(LAST_SEEN_CACHE_SIZE, hashImpression32);
-
-export default BrowserImpressionObserverFactory;

package/src/impressions/observer/node.js

@@ -1,8 +0,0 @@
-import ImpressionObserver from './observer';
-import { hashImpression128 } from '../hasher/hashImpression128';
-
-const LAST_SEEN_CACHE_SIZE = 500000; // cache up to 500k impression hashes
-
-const NodeImpressionObserverFactory = () => new ImpressionObserver(LAST_SEEN_CACHE_SIZE, hashImpression128);
-
-export default NodeImpressionObserverFactory;

package/src/impressions/observer/observer.js

@@ -1,17 +0,0 @@
-import LRU from '../../utils/lrucache/lrucache';
-
-class ImpressionObserver {
-  constructor(size, hasher) {
-    this.cache = new LRU(size);
-    this.hasher = hasher;
-  }
-
-  testAndSet(impression) {
-    const hash = this.hasher(impression);
-    const previous = this.cache.get(hash);
-    this.cache.set(hash, impression.time);
-    return previous;
-  }
-}
-
-export default ImpressionObserver;

package/src/impressions/observer/package.json

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

package/src/integrations/browser.js

@@ -1,57 +0,0 @@
-import GaToSplit from './ga/GaToSplit';
-import SplitToGa from './ga/SplitToGa';
-import { GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS, SPLIT_IMPRESSION, SPLIT_EVENT } from '../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.
- */
-const integrationsManagerFactory = context => {
-  const settings = context.get(context.constants.SETTINGS);
-
-  const listeners = [];
-
-  // No need to check if `settings.integrations` is an array. It was already validated in settings validation
-  settings.integrations.forEach(integrationOptions => {
-    const { type } = integrationOptions;
-    let integration;
-
-    switch (type) {
-      case GOOGLE_ANALYTICS_TO_SPLIT: {
-        const storage = context.get(context.constants.STORAGE);
-        const coreSettings = settings.core;
-        integration = GaToSplit(integrationOptions, storage, coreSettings);
-        break;
-      }
-
-      case SPLIT_TO_GOOGLE_ANALYTICS: {
-        integration = new SplitToGa(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 (impressionData) {
-      listeners.forEach(listener => listener.queue({ type: SPLIT_IMPRESSION, payload: impressionData }));
-    },
-    handleEvent: function (eventData) {
-      listeners.forEach(listener => listener.queue({ type: SPLIT_EVENT, payload: eventData }));
-    }
-  };
-
-};
-
-export default integrationsManagerFactory;