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

package/src/engine/transforms/whitelist.js

@@ -0,0 +1,22 @@
+/**
+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

@@ -0,0 +1,67 @@
+/**
+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

@@ -0,0 +1,53 @@
+/**
+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

@@ -0,0 +1,117 @@
+/**
+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

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

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

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

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

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

package/src/impressions/hasher/hashImpression128.js

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

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

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

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

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

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