@splitsoftware/splitio 10.16.0 → 10.16.1-rc.0

package/src/engine/matchers/types.js

@@ -15,28 +15,28 @@ limitations under the License.
 **/
 
 // @WARNING Symbol is not correctly working in PhantomJS
-export const types = {
-  ALL: 1,
-  SEGMENT: 2,
+export const matcherTypes = {
+  UNDEFINED: 0,
+  ALL_KEYS: 1,
+  IN_SEGMENT: 2,
   WHITELIST: 3,
   EQUAL_TO: 4,
   GREATER_THAN_OR_EQUAL_TO: 5,
   LESS_THAN_OR_EQUAL_TO: 6,
   BETWEEN: 7,
-  UNDEFINED: 8,
-  EQUAL_TO_SET: 9,
-  CONTAINS_ANY_OF_SET: 10,
-  CONTAINS_ALL_OF_SET: 11,
-  PART_OF_SET: 12,
-  ENDS_WITH: 13,
-  STARTS_WITH: 14,
-  CONTAINS_STRING: 15,
-  IN_SPLIT_TREATMENT: 16,
-  EQUAL_TO_BOOLEAN: 17,
-  MATCHES_STRING: 18
+  EQUAL_TO_SET: 8,
+  CONTAINS_ANY_OF_SET: 9,
+  CONTAINS_ALL_OF_SET: 10,
+  PART_OF_SET: 11,
+  ENDS_WITH: 12,
+  STARTS_WITH: 13,
+  CONTAINS_STRING: 14,
+  IN_SPLIT_TREATMENT: 15,
+  EQUAL_TO_BOOLEAN: 16,
+  MATCHES_STRING: 17
 };
 
-export const dataTypes = {
+export const matcherDataTypes = {
   BOOLEAN: 'BOOLEAN',
   STRING: 'STRING',
   NUMBER: 'NUMBER',
@@ -45,43 +45,8 @@ export const dataTypes = {
   NOT_SPECIFIED: 'NOT_SPECIFIED'
 };
 
-export const mapper = (matcherType) => {
-  switch (matcherType) {
-    case 'ALL_KEYS':
-      return types.ALL;
-    case 'IN_SEGMENT':
-      return types.SEGMENT;
-    case 'WHITELIST':
-      return types.WHITELIST;
-    case 'EQUAL_TO':
-      return types.EQUAL_TO;
-    case 'GREATER_THAN_OR_EQUAL_TO':
-      return types.GREATER_THAN_OR_EQUAL_TO;
-    case 'LESS_THAN_OR_EQUAL_TO':
-      return types.LESS_THAN_OR_EQUAL_TO;
-    case 'BETWEEN':
-      return types.BETWEEN;
-    case 'EQUAL_TO_SET':
-      return types.EQUAL_TO_SET;
-    case 'CONTAINS_ANY_OF_SET':
-      return types.CONTAINS_ANY_OF_SET;
-    case 'CONTAINS_ALL_OF_SET':
-      return types.CONTAINS_ALL_OF_SET;
-    case 'PART_OF_SET':
-      return types.PART_OF_SET;
-    case 'ENDS_WITH':
-      return types.ENDS_WITH;
-    case 'STARTS_WITH':
-      return types.STARTS_WITH;
-    case 'CONTAINS_STRING':
-      return types.CONTAINS_STRING;
-    case 'IN_SPLIT_TREATMENT':
-      return types.IN_SPLIT_TREATMENT;
-    case 'EQUAL_TO_BOOLEAN':
-      return types.EQUAL_TO_BOOLEAN;
-    case 'MATCHES_STRING':
-      return types.MATCHES_STRING;
-    default:
-      return types.UNDEFINED;
-  }
-};
+export function matcherTypesMapper(matcherType) {
+  const type = matcherTypes[matcherType];
+  if (type) return type;
+  else return matcherTypes.UNDEFINED;
+}

package/src/engine/transforms/matcherGroup.js

@@ -13,10 +13,7 @@ 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 {
-  types as matcherTypes,
-  mapper as matcherTypesMapper
-} from '../matchers/types';
+import { matcherTypes, matcherTypesMapper } from '../matchers/types';
 import segmentTransform from './segment';
 import whitelistTransform from './whitelist';
 
@@ -33,7 +30,7 @@ function transform(matcherGroup) {
   let type = matcherTypesMapper(matcherType);
   let value = undefined;
 
-  if (type === matcherTypes.SEGMENT) {
+  if (type === matcherTypes.IN_SEGMENT) {
     value = segmentTransform(segmentObject);
   } else if (type === matcherTypes.WHITELIST) {
     value = whitelistTransform(whitelistObject);

package/src/engine/transforms/matchers.js

@@ -15,11 +15,7 @@ limitations under the License.
 **/
 
 import { findIndex } from '../../utils/lang';
-import {
-  types as matcherTypes,
-  mapper as matcherTypesMapper,
-  dataTypes as matcherDataTypes
-} from '../matchers/types';
+import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/types';
 import segmentTransform from './segment';
 import whitelistTransform from './whitelist';
 import setTransform from './set';
@@ -49,7 +45,7 @@ function transform(matchers) {
     let dataType = matcherDataTypes.STRING;
     let value = undefined;
 
-    if (type === matcherTypes.SEGMENT) {
+    if (type === matcherTypes.IN_SEGMENT) {
       value = segmentTransform(segmentObject);
     } else if (type === matcherTypes.WHITELIST) {
       value = whitelistTransform(whitelistObject);

package/src/engine/value/sanitize.js

@@ -18,12 +18,7 @@ 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 {
-  types as matcherTypes,
-  dataTypes as matcherDataTypes
-} from '../matchers/types';
-const MATCHERS = matcherTypes;
-const DATA_TYPES = matcherDataTypes;
+import { matcherTypes, matcherDataTypes } from '../matchers/types';
 
 function sanitizeNumber(val) {
   const num = toNumber(val);
@@ -72,13 +67,13 @@ function dependencyProcessor(sanitizedValue, attributes) {
  */
 function getProcessingFunction(matcherTypeID, dataType) {
   switch (matcherTypeID) {
-    case MATCHERS.EQUAL_TO:
+    case matcherTypes.EQUAL_TO:
       return dataType === 'DATETIME' ? zeroSinceHH : undefined;
-    case MATCHERS.GREATER_THAN_OR_EQUAL_TO:
-    case MATCHERS.LESS_THAN_OR_EQUAL_TO:
-    case MATCHERS.BETWEEN:
+    case matcherTypes.GREATER_THAN_OR_EQUAL_TO:
+    case matcherTypes.LESS_THAN_OR_EQUAL_TO:
+    case matcherTypes.BETWEEN:
       return dataType === 'DATETIME' ? zeroSinceSS : undefined;
-    case MATCHERS.IN_SPLIT_TREATMENT:
+    case matcherTypes.IN_SPLIT_TREATMENT:
       return dependencyProcessor;
     default:
       return undefined;
@@ -90,20 +85,20 @@ function sanitizeValue(matcherTypeID, value, dataType, attributes) {
   let sanitizedValue;
 
   switch (dataType) {
-    case DATA_TYPES.NUMBER:
-    case DATA_TYPES.DATETIME:
+    case matcherDataTypes.NUMBER:
+    case matcherDataTypes.DATETIME:
       sanitizedValue = sanitizeNumber(value);
       break;
-    case DATA_TYPES.STRING:
+    case matcherDataTypes.STRING:
       sanitizedValue = sanitizeString(value);
       break;
-    case DATA_TYPES.SET:
+    case matcherDataTypes.SET:
       sanitizedValue = sanitizeArray(value);
       break;
-    case DATA_TYPES.BOOLEAN:
+    case matcherDataTypes.BOOLEAN:
       sanitizedValue = sanitizeBoolean(value);
       break;
-    case DATA_TYPES.NOT_SPECIFIED:
+    case matcherDataTypes.NOT_SPECIFIED:
       sanitizedValue = value;
       break;
     default:

package/src/impressions/hasher/hashImpression128.js

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

package/src/impressions/observer/observer.js

@@ -7,8 +7,6 @@ class ImpressionObserver {
   }
 
   testAndSet(impression) {
-    if (!impression) return null;
-
     const hash = this.hasher(impression);
     const previous = this.cache.get(hash);
     this.cache.set(hash, impression.time);

package/src/producer/updater/SplitChangesFromObject.js

@@ -13,6 +13,7 @@ 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 { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { forOwn } from '../../utils/lang';
 import logFactory from '../../utils/logger';
 const log = logFactory('splitio-producer:offline');
@@ -59,7 +60,6 @@ function FromObjectUpdaterFactory(Fetcher, context) {
 
       return Promise.all([
         storage.splits.flush(), // required to sync removed splits from mock
-        storage.splits.setChangeNumber(Date.now()),
         storage.splits.addSplits(splits)
       ]).then(() => {
         readiness.splits.emit(readiness.splits.SDK_SPLITS_ARRIVED);
@@ -67,7 +67,7 @@ function FromObjectUpdaterFactory(Fetcher, context) {
         if (startingUp) {
           startingUp = false;
           // Emits SDK_READY_FROM_CACHE
-          if (storage.splits.checkCache()) readiness.splits.emit(readiness.splits.SDK_SPLITS_CACHE_LOADED);
+          if (settings.storage.__originalType === STORAGE_LOCALSTORAGE) readiness.splits.emit(readiness.splits.SDK_SPLITS_CACHE_LOADED);
           // Only emits SDK_SEGMENTS_ARRIVED the first time for SDK_READY
           readiness.segments.emit(readiness.segments.SDK_SEGMENTS_ARRIVED);
         }

package/src/sync/PushManager/index.js

@@ -247,19 +247,12 @@ export default function PushManagerFactory(context, clientContexts /* undefined
           }
 
           forOwn(clients, ({ hash64, worker }) => {
-            if (added.has(hash64.dec)) {
+            const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
+            if (add !== undefined) {
               worker.put(parsedData.changeNumber, {
                 name: parsedData.segmentName,
-                add: true
+                add
               });
-              return;
-            }
-            if (removed.has(hash64.dec)) {
-              worker.put(parsedData.changeNumber, {
-                name: parsedData.segmentName,
-                add: false
-              });
-              return;
             }
           });
           return;

package/src/sync/constants.js

@@ -40,4 +40,4 @@ export const ControlTypes = {
   STREAMING_PAUSED: 'STREAMING_PAUSED',
   STREAMING_RESUMED: 'STREAMING_RESUMED',
   STREAMING_RESET: 'STREAMING_RESET'
-};
+};

package/src/utils/logger/LoggerFactory.js

@@ -5,17 +5,28 @@ import objectAssign from 'object-assign';
 
 export const LogLevels = {
   'DEBUG': 'DEBUG',
-  'INFO':  'INFO',
-  'WARN':  'WARN',
+  'INFO': 'INFO',
+  'WARN': 'WARN',
   'ERROR': 'ERROR',
   'NONE': 'NONE'
 };
 
+const LogLevelIndexes = {
+  DEBUG: 1,
+  INFO: 2,
+  WARN: 3,
+  ERROR: 4,
+  NONE: 5
+};
+
 // DEBUG is the default. The log level is not specific to an SDK instance.
-let GlobalLogLevel = LogLevels.DEBUG;
+let GlobalLogLevel = LogLevelIndexes.DEBUG;
 
+/**
+ * @param {'DEBUG'|'INFO'|'WARN'|'ERROR'|'NONE'} level
+ */
 export const setLogLevel = (level) => {
-  GlobalLogLevel = level;
+  GlobalLogLevel = LogLevelIndexes[level];
 };
 
 const defaultOptions = {
@@ -30,22 +41,22 @@ export class Logger {
   }
 
   debug(msg) {
-    if(this._shouldLog(LogLevels.DEBUG))
+    if (this._shouldLog(LogLevelIndexes.DEBUG))
       this._log(LogLevels.DEBUG, msg);
   }
 
   info(msg) {
-    if(this._shouldLog(LogLevels.INFO))
+    if (this._shouldLog(LogLevelIndexes.INFO))
       this._log(LogLevels.INFO, msg);
   }
 
   warn(msg) {
-    if(this._shouldLog(LogLevels.WARN))
+    if (this._shouldLog(LogLevelIndexes.WARN))
       this._log(LogLevels.WARN, msg);
   }
 
   error(msg) {
-    if(this.options.displayAllErrors || this._shouldLog(LogLevels.ERROR))
+    if (this.options.displayAllErrors || this._shouldLog(LogLevelIndexes.ERROR))
       this._log(LogLevels.ERROR, msg);
   }
 
@@ -59,8 +70,8 @@ export class Logger {
     const textPre = ' => ';
     let result = '';
 
-    if(this.options.showLevel) {
-      result += '[' + level +']' + (level === LogLevels.INFO || level === LogLevels.WARN ? ' ' : '') + ' ';
+    if (this.options.showLevel) {
+      result += '[' + level + ']' + (level === LogLevels.INFO || level === LogLevels.WARN ? ' ' : '') + ' ';
     }
 
     if (this.category) {
@@ -70,12 +81,10 @@ export class Logger {
     return result += text;
   }
 
+  /**
+   * @param {number} level
+   */
   _shouldLog(level) {
-    const logLevel = GlobalLogLevel;
-    const levels = Object.keys(LogLevels).map(f => LogLevels[f]);
-    const index = levels.indexOf(level); // What's the index of what it's trying to check if it should log
-    const levelIdx = levels.indexOf(logLevel); // What's the current log level index.
-
-    return index >= levelIdx;
+    return level >= GlobalLogLevel;
   }
 }

package/src/utils/settings/index.js

@@ -27,7 +27,7 @@ import { API } from '../../utils/logger';
 import { STANDALONE_MODE, STORAGE_MEMORY, CONSUMER_MODE, OPTIMIZED } from '../../utils/constants';
 import validImpressionsMode from './impressionsMode';
 
-const version = '10.16.0';
+const version = '10.16.1-rc.0';
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 const authEndpointMatcher = /^\/v2\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;

package/src/utils/settings/storage/browser.js

@@ -18,18 +18,21 @@ import logFactory from '../../../utils/logger';
 const log = logFactory('splitio-settings');
 import isLocalStorageAvailable from '../../../utils/localstorage/isAvailable';
 import {
+  LOCALHOST_MODE,
   STORAGE_MEMORY,
   STORAGE_LOCALSTORAGE
 } from '../../../utils/constants';
 
 const ParseStorageSettings = settings => {
   let {
+    mode,
     storage: {
       type = STORAGE_MEMORY,
       options = {},
       prefix
     },
   } = settings;
+  let __originalType;
 
   if (prefix) {
     prefix += '.SPLITIO';
@@ -37,18 +40,30 @@ const ParseStorageSettings = settings => {
     prefix = 'SPLITIO';
   }
 
+  const fallbackToMemory = () => {
+    __originalType = type;
+    type = STORAGE_MEMORY;
+  };
+
+  // In localhost mode, fallback to Memory storage and track original
+  // type to emit SDK_READY_FROM_CACHE if corresponds
+  if (mode === LOCALHOST_MODE && type === STORAGE_LOCALSTORAGE) {
+    fallbackToMemory();
+  }
+
   // If an invalid storage type is provided OR we want to use LOCALSTORAGE and
   // it's not available, fallback into MEMORY
   if (type !== STORAGE_MEMORY && type !== STORAGE_LOCALSTORAGE ||
-      type === STORAGE_LOCALSTORAGE && !isLocalStorageAvailable()) {
-    type = STORAGE_MEMORY;
+    type === STORAGE_LOCALSTORAGE && !isLocalStorageAvailable()) {
+    fallbackToMemory();
     log.warn('Invalid or unavailable storage. Fallbacking into MEMORY storage');
   }
 
   return {
     type,
     options,
-    prefix
+    prefix,
+    __originalType
   };
 };