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

package/src/client/inputValidation.js

@@ -0,0 +1,130 @@
+import objectAssign from 'object-assign';
+import ClientFactory from './client';
+import {
+  validateAttributes,
+  validateEvent,
+  validateEventValue,
+  validateEventProperties,
+  validateKey,
+  validateSplit,
+  validateSplits,
+  validateTrafficType,
+  validateIfDestroyed,
+  validateIfReady
+} from '../utils/inputValidation';
+import { startsWith } from '../utils/lang';
+import { STORAGE_REDIS, CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
+
+/**
+ * We will validate the input before actually executing the client methods. We should "guard" the client here,
+ * while not polluting the "real" implementation of those methods.
+ */
+function ClientInputValidationLayer(context, isKeyBinded, isTTBinded) {
+  const settings = context.get(context.constants.SETTINGS);
+  const isStorageSync = settings.storage.type !== STORAGE_REDIS;
+  // instantiate the client
+  const client = ClientFactory(context);
+  // Keep a reference to the original methods
+  const clientGetTreatment = client.getTreatment;
+  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+  const clientGetTreatments = client.getTreatments;
+  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+  const clientTrack = client.track;
+
+  /**
+   * Avoid repeating this validations code
+   */
+  function validateEvaluationParams(maybeKey, maybeSplitOrSplits, maybeAttributes, methodName) {
+    const multi = startsWith(methodName, 'getTreatments');
+    const key = isKeyBinded ? maybeKey : validateKey(maybeKey, methodName);
+    const splitOrSplits = multi ? validateSplits(maybeSplitOrSplits, methodName) : validateSplit(maybeSplitOrSplits, methodName);
+    const attributes = validateAttributes(maybeAttributes, methodName);
+    const isOperational = validateIfDestroyed(context);
+
+    validateIfReady(context, methodName);
+
+    const valid = isOperational && key && splitOrSplits && attributes !== false;
+
+    return {
+      valid,
+      key,
+      splitOrSplits,
+      attributes
+    };
+  }
+
+  client.getTreatment = function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
+    const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');
+
+    if (params.valid) {
+      return clientGetTreatment(params.key, params.splitOrSplits, params.attributes);
+    } else {
+      if (isStorageSync) return CONTROL;
+
+      return Promise.resolve(CONTROL);
+    }
+  };
+
+  client.getTreatmentWithConfig = function getTreatmentWithConfig(maybeKey, maybeSplit, maybeAttributes) {
+    const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatmentWithConfig');
+
+    if (params.valid) {
+      return clientGetTreatmentWithConfig(params.key, params.splitOrSplits, params.attributes);
+    } else {
+      if (isStorageSync) return objectAssign({}, CONTROL_WITH_CONFIG);
+
+      return Promise.resolve(objectAssign({}, CONTROL_WITH_CONFIG));
+    }
+  };
+
+  client.getTreatments = function getTreatments(maybeKey, maybeSplits, maybeAttributes) {
+    const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatments');
+
+    if (params.valid) {
+      return clientGetTreatments(params.key, params.splitOrSplits, params.attributes);
+    } else {
+      const res = {};
+      if (params.splitOrSplits) params.splitOrSplits.forEach(split => res[split] = CONTROL);
+
+      if (isStorageSync) return res;
+
+      return Promise.resolve(res);
+    }
+  };
+
+  client.getTreatmentsWithConfig = function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {
+    const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatmentsWithConfig');
+
+    if (params.valid) {
+      return clientGetTreatmentsWithConfig(params.key, params.splitOrSplits, params.attributes);
+    } else {
+      const res = {};
+      if (params.splitOrSplits) params.splitOrSplits.forEach(split => res[split] = objectAssign({}, CONTROL_WITH_CONFIG));
+
+      if (isStorageSync) return res;
+
+      return Promise.resolve(res);
+    }
+  };
+
+  client.track = function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
+    const key = isKeyBinded ? maybeKey : validateKey(maybeKey, 'track');
+    const tt = isTTBinded ? maybeTT : validateTrafficType(maybeTT, 'track');
+    const event = validateEvent(maybeEvent, 'track');
+    const eventValue = validateEventValue(maybeEventValue, 'track');
+    const { properties, size } = validateEventProperties(maybeProperties, 'track');
+    const isOperational = validateIfDestroyed(context);
+
+    if (isOperational && key && tt && event && eventValue !== false && properties !== false) {
+      return clientTrack(key, tt, event, eventValue, properties, size);
+    } else {
+      if (isStorageSync) return false;
+
+      return Promise.resolve(false);
+    }
+  };
+
+  return client;
+}
+
+export default ClientInputValidationLayer;

package/src/client/node.js

@@ -0,0 +1,8 @@
+import ClientWithInputValidationLayer from './inputValidation';
+
+export default function NodeClientFactory(context) {
+  const client = ClientWithInputValidationLayer(context);
+  client.isBrowserClient = false;
+
+  return client;
+}

package/src/client/package.json

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

package/src/engine/combiners/and.js

@@ -0,0 +1,55 @@
+/**
+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';
+import logFactory from '../../utils/logger';
+const log = logFactory('splitio-engine:combiner');
+import thenable from '../../utils/promise/thenable';
+
+function andResults(results) {
+  let i = 0;
+  let len = results.length;
+  let hasMatchedAll;
+
+  // loop through all the matchers an stop at the first one returning false.
+  for (; i < len && results[i]; i++) {
+    // logic is run inside the condition of evaluates next step.
+  }
+
+  hasMatchedAll = i === len;
+
+  log.debug(`[andCombiner] evaluates to ${hasMatchedAll}`);
+
+  return hasMatchedAll;
+}
+
+function andCombinerContext(matchers) {
+
+  function andCombiner(...params) {
+    const matcherResults = matchers.map(matcher => matcher(...params));
+
+    // If any matching result is a thenable we should use Promise.all
+    if (findIndex(matcherResults, thenable) !== -1) {
+      return Promise.all(matcherResults).then(andResults);
+    } else {
+      return andResults(matcherResults);
+    }
+  }
+
+  return andCombiner;
+}
+
+export default andCombinerContext;

package/src/engine/combiners/ifelseif.js

@@ -0,0 +1,74 @@
+/**
+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';
+import logFactory from '../../utils/logger';
+const log = logFactory('splitio-engine:combiner');
+import thenable from '../../utils/promise/thenable';
+import * as LabelsConstants from '../../utils/labels';
+import { CONTROL } from '../../utils/constants';
+
+function unexpectedInputHandler() {
+  log.error('Invalid Split provided, no valid conditions found');
+
+  return {
+    treatment: CONTROL,
+    label: LabelsConstants.EXCEPTION
+  };
+}
+
+function computeTreatment(predicateResults) {
+  const len = predicateResults.length;
+
+  for (let i = 0; i < len; i++) {
+    const evaluation = predicateResults[i];
+
+    if (evaluation !== undefined) {
+      log.debug(`Treatment found: ${evaluation.treatment}`);
+
+      return evaluation;
+    }
+  }
+
+  log.debug('All predicates evaluated, no treatment found.');
+  return undefined;
+}
+
+function ifElseIfCombinerContext(predicates) {
+
+  function ifElseIfCombiner(key, seed, trafficAllocation, trafficAllocationSeed, attributes, algo, splitEvaluator) {
+    // In Async environments we are going to have async predicates. There is none way to know
+    // before hand so we need to evaluate all the predicates, verify for thenables, and finally,
+    // define how to return the treatment (wrap result into a Promise or not).
+    const predicateResults = predicates.map(evaluator => evaluator(key, seed, trafficAllocation, trafficAllocationSeed, splitEvaluator, attributes, algo));
+
+    // if we find a thenable
+    if (findIndex(predicateResults, thenable) !== -1) {
+      return Promise.all(predicateResults).then(results => computeTreatment(results));
+    }
+
+    return computeTreatment(predicateResults);
+  }
+
+  // if there is none predicates, then there was an error in parsing phase
+  if (!Array.isArray(predicates) || Array.isArray(predicates) && predicates.length === 0) {
+    return unexpectedInputHandler;
+  } else {
+    return ifElseIfCombiner;
+  }
+}
+
+export default ifElseIfCombinerContext;

package/src/engine/condition/index.js

@@ -0,0 +1,65 @@
+/**
+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 engine from '../engine';
+import thenable from '../../utils/promise/thenable';
+import * as LabelsConstants from '../../utils/labels';
+
+// Build Evaluation object if and only if matchingResult is true
+function match(matchingResult, bucketingKey, seed, treatments, label, algo) {
+  if (matchingResult) {
+    const treatment = engine.getTreatment(bucketingKey, seed, treatments, algo);
+
+    return {
+      treatment,
+      label
+    };
+  }
+
+  // else we should notify the engine to continue evaluating
+  return undefined;
+}
+
+// Condition factory
+function conditionContext(matcherEvaluator, treatments, label, conditionType) {
+
+  function conditionEvaluator(key, seed, trafficAllocation, trafficAllocationSeed, splitEvaluator, attributes, algo) {
+
+    // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
+    if (conditionType === 'ROLLOUT' && !engine.shouldApplyRollout(trafficAllocation, key.bucketingKey, trafficAllocationSeed, algo)) {
+      return {
+        treatment: undefined,
+        label: LabelsConstants.NOT_IN_SPLIT
+      };
+    }
+
+    // matcherEvaluator could be Async, this relays on matchers return value, so we need
+    // to verify for thenable before play with the result.
+    // Also, we pass splitEvaluator function in case we have a matcher that needs to evaluate another split,
+    // as well as the entire key object for the same reason.
+    const matches = matcherEvaluator(key, attributes, splitEvaluator);
+
+    if (thenable(matches)) {
+      return matches.then(result => match(result, key.bucketingKey, seed, treatments, label, algo));
+    }
+
+    return match(matches, key.bucketingKey, seed, treatments, label, algo);
+  }
+
+  return conditionEvaluator;
+}
+
+export default conditionContext;

package/src/engine/convertions/index.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.
+**/
+export function zeroSinceHH(millisSinceEpoch /*: number */) /*: number */ {
+  return new Date(millisSinceEpoch).setUTCHours(0, 0, 0, 0);
+}
+
+export function zeroSinceSS(millisSinceEpoch /*: number */) /*: number */ {
+  return new Date(millisSinceEpoch).setUTCSeconds(0, 0);
+}

package/src/engine/engine/index.js

@@ -0,0 +1,63 @@
+/**
+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');
+import legacy from './legacy';
+import murmur from './murmur3/murmur3';
+const MURMUR_ID = 2;
+
+/**
+ * Returns the bucket function by algoId.
+ */
+function getBucketAlgo(algoId) {
+  if (algoId === MURMUR_ID) {
+    return murmur.bucket;
+  } else {
+    return legacy.bucket;
+  }
+}
+
+const engine = {
+  /**
+   * Get the treatment name given a key, a seed, and the percentage of each treatment.
+   */
+  getTreatment(key, seed, treatments, algoId) {
+    const bucket = getBucketAlgo(algoId)(key, seed);
+
+    const treatment = treatments.getTreatmentFor(bucket);
+
+    log.debug(`[engine] using algo ${algoId !== MURMUR_ID ? 'legacy' : 'murmur'} bucket ${bucket} for key ${key} using seed ${seed} - treatment ${treatment}`);
+
+    return treatment;
+  },
+  /**
+   * Evaluates the traffic allocation to see if we should apply rollout conditions or not.
+   */
+  shouldApplyRollout(trafficAllocation, key, trafficAllocationSeed, algoId) {
+    // For rollout, if traffic allocation for splits is 100%, we don't need to filter it because everything should evaluate the rollout.
+    if (trafficAllocation < 100) {
+      const bucket = getBucketAlgo(algoId)(key, trafficAllocationSeed);
+
+      if (bucket > trafficAllocation) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+export default engine;

package/src/engine/engine/legacy.js

@@ -0,0 +1,66 @@
+/**
+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.
+**/
+//
+// JAVA reference implementation for the hashing function.
+//
+// int h = 0;
+// for (int i = 0; i < key.length(); i++) {
+//     h = 31 * h + key.charAt(i);
+// }
+// return h ^ seed; // XOR the hash and seed
+//
+
+function ToInteger(x) {
+  x = Number(x);
+  return x < 0 ? Math.ceil(x) : Math.floor(x);
+}
+
+function modulo(a, b) {
+  return a - Math.floor(a / b) * b;
+}
+
+function ToUint32(x) {
+  return modulo(ToInteger(x), Math.pow(2, 32));
+}
+
+function ToInt32(x) {
+  let uint32 = ToUint32(x);
+
+  if (uint32 >= Math.pow(2, 31)) {
+    return uint32 - Math.pow(2, 32);
+  } else {
+    return uint32;
+  }
+}
+
+function hash(str /*: string */, seed /*: number */) /*: number */ {
+  let h = 0;
+
+  for (let i = 0; i < str.length; i++) {
+    h = ToInt32(ToInt32(31 * h) + str.charCodeAt(i));
+  }
+
+  return ToInt32(h ^ seed);
+}
+
+function bucket(str /*: string */, seed /*: number */) /*: number */ {
+  return Math.abs(hash(str, seed) % 100) + 1;
+}
+
+export default {
+  hash,
+  bucket
+};

package/src/engine/engine/murmur3/common.js

@@ -0,0 +1,54 @@
+import { stringSource, stringDestination, encodeUTF16toUTF8 } from './utfx';
+
+export function UTF16ToUTF8(key) {
+  let sd;
+
+  encodeUTF16toUTF8(
+    stringSource(key),
+    sd = stringDestination()
+  );
+
+  return sd();
+}
+
+/*!
+ * +----------------------------------------------------------------------------------+
+ * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
+ * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
+ * |----------------------------------------------------------------------------------|
+ * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
+ * +----------------------------------------------------------------------------------+
+ */
+
+export function x86Multiply(m, n) {
+  //
+  // Given two 32bit ints, returns the two multiplied together as a
+  // 32bit int.
+  //
+
+  return ((m & 0xffff) * n) + ((((m >>> 16) * n) & 0xffff) << 16);
+}
+
+
+export function x86Rotl(m, n) {
+  //
+  // Given a 32bit int and an int representing a number of bit positions,
+  // returns the 32bit int rotated left by that number of positions.
+  //
+
+  return (m << n) | (m >>> (32 - n));
+}
+
+export function x86Fmix(h) {
+  //
+  // Given a block, returns murmurHash3's final x86 mix of that block.
+  //
+
+  h ^= h >>> 16;
+  h = x86Multiply(h, 0x85ebca6b);
+  h ^= h >>> 13;
+  h = x86Multiply(h, 0xc2b2ae35);
+  h ^= h >>> 16;
+
+  return h;
+}

package/src/engine/engine/murmur3/murmur3.js

@@ -0,0 +1,79 @@
+/* eslint-disable no-fallthrough */
+import { UTF16ToUTF8, x86Fmix, x86Multiply, x86Rotl } from './common';
+
+/*!
+ * +----------------------------------------------------------------------------------+
+ * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
+ * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
+ * |----------------------------------------------------------------------------------|
+ * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
+ * +----------------------------------------------------------------------------------+
+ */
+
+// PUBLIC FUNCTIONS
+// ----------------
+function hash32(key, seed) {
+  //
+  // Given a string and an optional seed as an int, returns a 32 bit hash
+  // using the x86 flavor of MurmurHash3, as an unsigned int.
+  //
+
+  key = key || '';
+  seed = seed || 0;
+
+  var remainder = key.length % 4;
+  var bytes = key.length - remainder;
+
+  var h1 = seed;
+
+  var k1 = 0;
+
+  var c1 = 0xcc9e2d51;
+  var c2 = 0x1b873593;
+
+  for (var i = 0; i < bytes; i = i + 4) {
+    k1 = ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24);
+
+    k1 = x86Multiply(k1, c1);
+    k1 = x86Rotl(k1, 15);
+    k1 = x86Multiply(k1, c2);
+
+    h1 ^= k1;
+    h1 = x86Rotl(h1, 13);
+    h1 = x86Multiply(h1, 5) + 0xe6546b64;
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= (key.charCodeAt(i) & 0xff);
+      k1 = x86Multiply(k1, c1);
+      k1 = x86Rotl(k1, 15);
+      k1 = x86Multiply(k1, c2);
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 = x86Fmix(h1);
+
+  return h1 >>> 0;
+}
+
+function hash(str /*: string */, seed /*: number */) /*: number */ {
+  return hash32(UTF16ToUTF8(str), seed >>> 0);
+}
+
+function bucket(str /*: string */, seed /*: number */) /*: number */ {
+  return Math.abs(hash(str, seed) % 100) + 1;
+}
+
+export default {
+  hash,
+  bucket,
+};