splitclient-rb 4.4.0 → 4.5.1.pre.dev

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e90a30df4c1f1e86befc5572851f37cee1e22eec
-  data.tar.gz: 8b7eeb1065058af7efe9ec9b104d4b0bd589d199
+  metadata.gz: 35f1c408826430c3833af34b39b302e005b0e3d3
+  data.tar.gz: ee0fa5c89c7cb7a30dd0a18fa63dc645673170d9
 SHA512:
-  metadata.gz: da5a3fc027744717443eb00c87615444890b5cccc6c018baf89f93bd111fba8951ca1f64bdab839eead72e907befee279727402961dfb56dd1e02d8d410bc046
-  data.tar.gz: a86cd66443680a28c0b207f08cf8ff0c8e0e3130ecd9c77f542a419209c0786b3cbfe4fea4d3dc6d4afb07acb7344ac335d9478834f0a063ca3fc2e01141f910
+  metadata.gz: a324c37b240280be2de970a9f028095bb27cacf59bfc41c8408c509c19997933cfa90211953856c2840df9c9683e128c281b3ba33c8a2296d236cb1d97f920bc
+  data.tar.gz: a129c6547c71383840c78e5520d4ce544a483bea9eb5b05c09d7c1e87dfdc79b141afe0c73645e4f5b861adafd18230a341d095005cc1e455d63d0053e2b98d6

data/.gitignore

@@ -36,3 +36,10 @@ Gemfile.lock
 
 # Ignore Byebug command history file.
 .byebug_history
+
+# Ignore built extensions
+lib/murmurhash/murmurhash.bundle
+lib/murmurhash/murmurhash.so
+
+ext/murmurhash/murmurhash.bundle
+ext/murmurhash/murmurhash.so

data/CHANGES.txt

@@ -1,3 +1,12 @@
+4.5.1 (Mar 23rd, 2018)
+- Fix Forwardable load issue
+- Fix native extension path issue
+
+4.5.0 (Mar 2nd, 2018)
+
+- Move MurmurHash3 implementation inside the gem
+- Add native Java MurmurHash3 implementation -> now support JRuby
+
 4.4.0 (Feb 5th, 2018)
 - Add track API
 

data/NEWS

@@ -1,3 +1,7 @@
+4.5.0
+
+Add JRuby support
+
 4.4.0
 
 Add the ability to send event data to split service (.track() api)

data/README.md

@@ -1,3 +1,5 @@
+[ ![Codeship Status for splitio/ruby-client](https://app.codeship.com/projects/306c6b60-c164-0133-e179-16471d4e6045/status?branch=master)](https://app.codeship.com/projects/137510)
+
 # Split Ruby SDK
 
 This SDK is designed to work with [Split](https://www.split.io), the platform for controlled rollouts, serving features to your users via the Split feature flag to manage your complete customer experience.

data/Rakefile

@@ -1,4 +1,24 @@
-require "bundler/gem_tasks"
-task :default => :spec
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+RSpec::Core::RakeTask.new(:spec)
 
-Dir.glob('tasks/**/*.rake').each(&method(:import))
+task :spec => :compile
+case RUBY_PLATFORM
+when 'java'
+  require 'rake/javaextensiontask'
+  Rake::JavaExtensionTask.new 'murmurhash' do |ext|
+    ext.lib_dir = 'lib/murmurhash'
+    ext.target_version = '1.7'
+    ext.source_version = '1.7'
+  end
+else
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new 'murmurhash' do |ext|
+    ext.lib_dir = 'lib/murmurhash'
+  end
+end
+
+task :default => :spec

data/ext/murmurhash/3_x86_32.c

@@ -0,0 +1,88 @@
+/*
+ * MurmurHash3_x86_32 (C) Austin Appleby
+ */
+
+#include "murmurhash.h"
+
+uint32_t
+murmur_hash_process3_x86_32(const char * key, uint32_t len, uint32_t seed)
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 4;
+  int i;
+
+  uint32_t h1 = seed;
+
+  const uint32_t c1 = 0xcc9e2d51;
+  const uint32_t c2 = 0x1b873593;
+
+  //----------
+  // body
+
+  const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
+
+  for(i = -nblocks; i; i++)
+  {
+    uint32_t k1 = getblock32(blocks,i);
+
+    k1 *= c1;
+    k1 = ROTL32(k1,15);
+    k1 *= c2;
+
+    h1 ^= k1;
+    h1 = ROTL32(h1,13);
+    h1 = h1*5+0xe6546b64;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
+
+  uint32_t k1 = 0;
+
+  switch(len & 3)
+  {
+  case 3: k1 ^= tail[2] << 16;
+  case 2: k1 ^= tail[1] << 8;
+  case 1: k1 ^= tail[0];
+          k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= len;
+
+  h1 = fmix32(h1);
+
+  return h1;
+}
+
+VALUE
+murmur3_x86_32_finish(VALUE self)
+{
+  uint8_t digest[4];
+  uint32_t h;
+
+  h = _murmur_finish32(self, murmur_hash_process3_x86_32);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur3_x86_32_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+  uint8_t digest[4];
+  uint32_t h;
+
+  h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process3_x86_32);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur3_x86_32_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+  return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process3_x86_32));
+}

data/ext/murmurhash/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('murmurhash/murmurhash')

data/ext/murmurhash/murmurhash.c

@@ -0,0 +1,251 @@
+#include "murmurhash.h"
+
+ID id_DEFAULT_SEED;
+ID iv_seed;
+ID iv_buffer;
+
+
+inline uint32_t rotl32 ( uint32_t x, int8_t r )
+{
+  return (x << r) | (x >> (32 - r));
+}
+inline uint64_t rotl64 ( uint64_t x, int8_t r )
+{
+  return (x << r) | (x >> (64 - r));
+}
+
+FORCE_INLINE uint32_t getblock32 ( const uint32_t * p, int i )
+{
+  return p[i];
+}
+
+FORCE_INLINE uint64_t getblock64 ( const uint64_t * p, int i )
+{
+  return p[i];
+}
+
+FORCE_INLINE uint32_t fmix32 ( uint32_t h )
+{
+  h ^= h >> 16;
+  h *= 0x85ebca6b;
+  h ^= h >> 13;
+  h *= 0xc2b2ae35;
+  h ^= h >> 16;
+
+  return h;
+}
+
+FORCE_INLINE uint64_t fmix64 ( uint64_t k )
+{
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xff51afd7ed558ccd);
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
+  k ^= k >> 33;
+
+  return k;
+}
+
+void
+assign_by_endian_32(uint8_t *digest, uint32_t h)
+{
+  if (BIGENDIAN_P()) {
+    digest[0] = h >> 24;
+    digest[1] = h >> 16;
+    digest[2] = h >> 8;
+    digest[3] = h;
+  }
+  else {
+    digest[3] = h >> 24;
+    digest[2] = h >> 16;
+    digest[1] = h >> 8;
+    digest[0] = h;
+  }
+}
+
+void
+assign_by_endian_64(uint8_t *digest, uint64_t h)
+{
+  if (BIGENDIAN_P()) {
+    digest[0] = h >> 56;
+    digest[1] = h >> 48;
+    digest[2] = h >> 40;
+    digest[3] = h >> 32;
+    digest[4] = h >> 24;
+    digest[5] = h >> 16;
+    digest[6] = h >> 8;
+    digest[7] = h;
+  }
+  else {
+    digest[7] = h >> 56;
+    digest[6] = h >> 48;
+    digest[5] = h >> 40;
+    digest[4] = h >> 32;
+    digest[3] = h >> 24;
+    digest[2] = h >> 16;
+    digest[1] = h >> 8;
+    digest[0] = h;
+  }
+}
+
+void
+assign_by_endian_128(uint8_t *digest, void *out)
+{
+  int i;
+
+  if (BIGENDIAN_P()) {
+    for (i = 0; i < 4; i++) {
+      digest[(i*4)  ] = ((uint32_t*)out)[i] >> 24;
+      digest[(i*4)+1] = ((uint32_t*)out)[i] >> 16;
+      digest[(i*4)+2] = ((uint32_t*)out)[i] >> 8;
+      digest[(i*4)+3] = ((uint32_t*)out)[i];
+    }
+  }
+  else {
+    for (i = 0; i < 4; i++) {
+      digest[16-(i*4)-1] = ((uint32_t*)out)[i] >> 24;
+      digest[16-(i*4)-2] = ((uint32_t*)out)[i] >> 16;
+      digest[16-(i*4)-3] = ((uint32_t*)out)[i] >> 8;
+      digest[16-(i*4)-4] = ((uint32_t*)out)[i];
+    }
+  }
+}
+
+static uint32_t
+rstring2uint32_t(VALUE str)
+{
+  long len = RSTRING_LEN(str);
+  if (UINT32_MAX < len) {
+    rb_raise(rb_eRangeError, "String length=%ld will overflow from long to uint32_t", len);
+  }
+  return (uint32_t)len;
+}
+
+uint32_t
+_murmur_finish32(VALUE self, uint32_t (*process)(const char*, uint32_t, uint32_t))
+{
+  const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
+  VALUE buffer = rb_ivar_get(self, iv_buffer);
+  return process(RSTRING_PTR(buffer), rstring2uint32_t(buffer), *(uint32_t*)seed);
+}
+
+uint64_t
+_murmur_finish64(VALUE self, uint64_t (*process)(const char*, uint32_t, uint64_t))
+{
+  const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
+  VALUE buffer = rb_ivar_get(self, iv_buffer);
+  return process(RSTRING_PTR(buffer), rstring2uint32_t(buffer), *(uint64_t*)seed);
+}
+
+void
+_murmur_finish128(VALUE self, void *out, void (*process)(const char*, uint32_t, uint32_t, void*))
+{
+  const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
+  VALUE buffer = rb_ivar_get(self, iv_buffer);
+  process(RSTRING_PTR(buffer), rstring2uint32_t(buffer), *(uint32_t*)seed, out);
+}
+
+uint32_t
+_murmur_s_digest32(int argc, VALUE *argv, VALUE klass, uint32_t (*process)(const char *, uint32_t, uint32_t))
+{
+  VALUE str;
+  const char *seed;
+
+  if (argc < 1)
+    rb_raise(rb_eArgError, "no data given");
+
+  str = *argv;
+
+  StringValue(str);
+
+  if (1 < argc) {
+    StringValue(argv[1]);
+    if (RSTRING_LEN(argv[1]) != 4) {
+      rb_raise(rb_eArgError, "seed string should be 4 length");
+    }
+    seed = RSTRING_PTR(argv[1]);
+  } else {
+    seed = RSTRING_PTR(rb_const_get(klass, id_DEFAULT_SEED));
+  }
+
+  return process(RSTRING_PTR(str), rstring2uint32_t(str), *(uint32_t*)seed);
+}
+
+uint64_t
+_murmur_s_digest64(int argc, VALUE *argv, VALUE klass, uint64_t (*process)(const char *, uint32_t, uint64_t))
+{
+  VALUE str;
+  const char *seed;
+
+  if (argc < 1)
+    rb_raise(rb_eArgError, "no data given");
+
+  str = *argv;
+
+  StringValue(str);
+
+  if (1 < argc) {
+    StringValue(argv[1]);
+    if (RSTRING_LEN(argv[1]) != 8) {
+      rb_raise(rb_eArgError, "seed string should be 8 length");
+    }
+    seed = RSTRING_PTR(argv[1]);
+  } else {
+    seed = RSTRING_PTR(rb_const_get(klass, id_DEFAULT_SEED));
+  }
+
+  return process(RSTRING_PTR(str), rstring2uint32_t(str), *(uint64_t*)seed);
+}
+
+void
+_murmur_s_digest128(int argc, VALUE *argv, VALUE klass, void *out, void (*process)(const char *, uint32_t, uint32_t, void *))
+{
+  VALUE str;
+  const char *seed;
+  int seed_length = 4;
+
+  if (argc < 1)
+    rb_raise(rb_eArgError, "no data given");
+
+  str = *argv;
+
+  StringValue(str);
+
+  if (1 < argc) {
+    StringValue(argv[1]);
+    if (RSTRING_LEN(argv[1]) != seed_length) {
+      rb_raise(rb_eArgError, "seed string should be %d length", seed_length);
+    }
+    seed = RSTRING_PTR(argv[1]);
+  } else {
+    seed = RSTRING_PTR(rb_const_get(klass, id_DEFAULT_SEED));
+  }
+
+  process(RSTRING_PTR(str), rstring2uint32_t(str), *(uint32_t*)seed, out);
+}
+
+
+void
+Init_murmurhash(void)
+{
+  VALUE cDigest_MurmurHash1,
+        cDigest_MurmurHash2,
+        cDigest_MurmurHash2A,
+        cDigest_MurmurHash64A,
+        cDigest_MurmurHash64B,
+        cDigest_MurmurHashNeutral2,
+        cDigest_MurmurHashAligned2,
+        cDigest_MurmurHash3_x86_32,
+        cDigest_MurmurHash3_x86_128,
+        cDigest_MurmurHash3_x64_128;
+
+  id_DEFAULT_SEED = rb_intern("DEFAULT_SEED");
+  iv_seed = rb_intern("@seed");
+  iv_buffer = rb_intern("@buffer");
+
+
+  cDigest_MurmurHash3_x86_32 = rb_path2class("Digest::MurmurHashMRI3_x86_32");
+  rb_define_singleton_method(cDigest_MurmurHash3_x86_32, "digest", murmur3_x86_32_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash3_x86_32, "rawdigest", murmur3_x86_32_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash3_x86_32, "finish", murmur3_x86_32_finish, 0);
+}

data/ext/murmurhash/murmurhash.h

@@ -0,0 +1,94 @@
+#ifndef MURMURHASH_INCLUDED
+#  define MURMURHASH_INCLUDED
+
+#include "ruby.h"
+
+// Microsoft Visual Studio
+
+#if defined(_MSC_VER)
+  #define FORCE_INLINE    __forceinline
+  #include <stdlib.h>
+  #define ROTL32(x,y)     _rotl(x,y)
+  #define ROTL64(x,y)     _rotl64(x,y)
+  #define BIG_CONSTANT(x) (x)
+#else   // defined(_MSC_VER)
+  #define FORCE_INLINE inline __attribute__((always_inline))
+  #define ROTL32(x,y)     rotl32(x,y)
+  #define ROTL64(x,y)     rotl64(x,y)
+  #define BIG_CONSTANT(x) (x##LLU)
+#endif // !defined(_MSC_VER)
+
+#ifdef DYNAMIC_ENDIAN
+  /* for universal binary of NEXTSTEP and MacOS X */
+  /* useless since autoconf 2.63? */
+  static int
+  is_bigendian(void)
+  {
+    static int init = 0;
+    static int endian_value;
+    char *p;
+
+    if (init) return endian_value;
+    init = 1;
+    p = (char*)&init;
+    return endian_value = p[0] ? 0 : 1;
+  }
+#  define BIGENDIAN_P() (is_bigendian())
+#elif defined(WORDS_BIGENDIAN)
+#  define BIGENDIAN_P() 1
+#else
+#  define BIGENDIAN_P() 0
+#endif
+
+#define MURMURHASH_MAGIC 0x5bd1e995
+#define MURMURHASH_MAGIC64A BIG_CONSTANT(0xc6a4a7935bd1e995)
+
+void assign_by_endian_32(uint8_t *digest, uint32_t h);
+void assign_by_endian_64(uint8_t *digest, uint64_t h);
+void assign_by_endian_128(uint8_t*, void*);
+
+uint32_t rotl32(uint32_t, int8_t);
+uint64_t rotl64(uint64_t, int8_t);
+uint32_t getblock32(const uint32_t*, int);
+uint64_t getblock64(const uint64_t*, int);
+uint32_t fmix32(uint32_t);
+uint64_t fmix64(uint64_t);
+uint32_t _murmur_finish32(VALUE, uint32_t (*)(const char*, uint32_t, uint32_t));
+uint64_t _murmur_finish64(VALUE, uint64_t (*)(const char*, uint32_t, uint64_t));
+void _murmur_finish128(VALUE, void*, void (*)(const char*, uint32_t, uint32_t, void*));
+uint32_t _murmur_s_digest32(int, VALUE*, VALUE, uint32_t (*)(const char*, uint32_t, uint32_t));
+uint64_t _murmur_s_digest64(int, VALUE*, VALUE, uint64_t (*)(const char*, uint32_t, uint64_t));
+void _murmur_s_digest128(int, VALUE*, VALUE, void*, void (*)(const char*, uint32_t, uint32_t, void*));
+
+VALUE murmur1_finish(VALUE);
+VALUE murmur1_s_digest(int, VALUE*, VALUE);
+VALUE murmur1_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur2_finish(VALUE);
+VALUE murmur2_s_digest(int, VALUE*, VALUE);
+VALUE murmur2_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur2a_finish(VALUE);
+VALUE murmur2a_s_digest(int, VALUE*, VALUE);
+VALUE murmur2a_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur64a_finish(VALUE);
+VALUE murmur64a_s_digest(int, VALUE*, VALUE);
+VALUE murmur64a_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur64b_finish(VALUE);
+VALUE murmur64b_s_digest(int, VALUE*, VALUE);
+VALUE murmur64b_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur_neutral2_finish(VALUE);
+VALUE murmur_neutral2_s_digest(int, VALUE*, VALUE);
+VALUE murmur_neutral2_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur_aligned2_finish(VALUE);
+VALUE murmur_aligned2_s_digest(int, VALUE*, VALUE);
+VALUE murmur_aligned2_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur3_x86_32_finish(VALUE);
+VALUE murmur3_x86_32_s_digest(int, VALUE*, VALUE);
+VALUE murmur3_x86_32_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur3_x86_128_finish(VALUE);
+VALUE murmur3_x86_128_s_digest(int, VALUE*, VALUE);
+VALUE murmur3_x86_128_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur3_x64_128_finish(VALUE);
+VALUE murmur3_x64_128_s_digest(int, VALUE*, VALUE);
+VALUE murmur3_x64_128_s_rawdigest(int, VALUE*, VALUE);
+
+#endif /* ifndef MURMURHASH_INCLUDED */

data/lib/murmurhash/base.rb

@@ -0,0 +1,58 @@
+module Digest
+  ds = Struct.new(:digest_length, :seed_length)
+  s1 = ds.new(4, 4)
+  s2 = ds.new(8, 8)
+  s3 = ds.new(16, 4)
+  {
+    '1' => s1,
+    '2' => s1,
+    '2A' => s1,
+    '64A' => s2,
+    '64B' => s2,
+    'Aligned2' => s1,
+    'Neutral2' => s1,
+    '3_x86_32' => s1,
+    '3_x86_128' => s3,
+    '3_x64_128' => s3,
+  }.each do |name, s|
+    class_eval %Q{
+      class MurmurHashMRI#{name} < Digest::Class
+        DEFAULT_SEED = "#{"\x00" * s.seed_length}".b
+
+        def initialize
+          @buffer = ""
+          @seed = DEFAULT_SEED
+        end
+
+        def update(str)
+          @buffer << str
+          self
+        end
+        alias << update
+
+        def reset
+          @buffer.clear
+          @seed = DEFAULT_SEED
+          self
+        end
+
+        def seed
+          @seed
+        end
+
+        def seed=(s)
+          raise ArgumentError, "seed string should be #{s.seed_length} length" if #{s.seed_length} != s.length
+          @seed = s
+        end
+
+        def digest_length
+          #{s.digest_length}
+        end
+
+        def block_length
+          0
+        end
+      end
+    }
+  end
+end

data/lib/murmurhash/murmurhash_mri.rb

@@ -0,0 +1,3 @@
+require 'digest'
+require 'murmurhash/base'
+require 'murmurhash/murmurhash'

data/lib/splitclient-rb/cache/repositories/impressions_repository.rb

@@ -1,5 +1,3 @@
-require 'forwardable'
-
 module SplitIoClient
   module Cache
     module Repositories

data/lib/splitclient-rb/engine/evaluator/splitter.rb

@@ -1,118 +1,123 @@
-require 'digest/murmurhash'
-
 module SplitIoClient
   # Misc class in charge of providing hash functions and
   # determination of treatment based on concept of buckets
   # based on provided key
   #
   class Splitter < NoMethodError
-    class << self
-      #
-      # Checks if the partiotion size is 100%
-      #
-      # @param partitions [object] array of partitions
-      #
-      # @return [boolean] true if partition is 100% false otherwise
-      def hundred_percent_one_treatment?(partitions)
-        (partitions.size != 1) ? false : (partitions.first.size == 100)
+    def initialize
+      @murmur_hash = case RUBY_PLATFORM
+      when 'java' 
+        Proc.new { |key, seed| Java::MurmurHash3.murmurhash3_x86_32(key, seed) }
+      else
+        Proc.new { |key, seed| Digest::MurmurHashMRI3_x86_32.rawdigest(key, [seed].pack('L')) }
       end
+    end
+    
+    #
+    # Checks if the partiotion size is 100%
+    #
+    # @param partitions [object] array of partitions
+    #
+    # @return [boolean] true if partition is 100% false otherwise
+    def hundred_percent_one_treatment?(partitions)
+      (partitions.size != 1) ? false : (partitions.first.size == 100)
+    end
 
-      #
-      # gets the appropriate treatment based on id, seed and partition value
-      #
-      # @param id [string] user key
-      # @param seed [number] seed for the user key
-      # @param partitions [object] array of partitions
-      #
-      # @return traetment [object] treatment value
-      def get_treatment(id, seed, partitions, legacy_algo)
-        legacy = (legacy_algo == 1 || legacy_algo == nil) ? true : false
-
-        if partitions.empty?
-          return SplitIoClient::Engine::Models::Treatment::CONTROL
-        end
-
-        if hundred_percent_one_treatment?(partitions)
-          return (partitions.first).treatment
-        end
-
-        return get_treatment_for_key(bucket(count_hash(id, seed, legacy_algo)), partitions)
+    #
+    # gets the appropriate treatment based on id, seed and partition value
+    #
+    # @param id [string] user key
+    # @param seed [number] seed for the user key
+    # @param partitions [object] array of partitions
+    #
+    # @return traetment [object] treatment value
+    def get_treatment(id, seed, partitions, legacy_algo)
+      legacy = [1, nil].include?(legacy_algo)
+
+      if partitions.empty?
+        return SplitIoClient::Engine::Models::Treatment::CONTROL
       end
 
-      # returns a hash value for the give key, seed pair
-      #
-      # @param key [String] user key
-      # @param seed [Fixnum] seed for the user key
-      #
-      # @return hash [String] hash value
-      def count_hash(key, seed, legacy)
-        legacy ? legacy_hash(key, seed) : murmur_hash(key, seed)
+      if hundred_percent_one_treatment?(partitions)
+        return (partitions.first).treatment
       end
 
-      def murmur_hash(key, seed)
-        Digest::MurmurHash3_x86_32.rawdigest(key, [seed].pack('L'))
-      end
+      return get_treatment_for_key(bucket(count_hash(id, seed, legacy_algo)), partitions)
+    end
 
-      def legacy_hash(key, seed)
-        h = 0
+    # returns a hash value for the give key, seed pair
+    #
+    # @param key [String] user key
+    # @param seed [Fixnum] seed for the user key
+    #
+    # @return hash [String] hash value
+    def count_hash(key, seed, legacy)
+      legacy ? legacy_hash(key, seed) : murmur_hash(key, seed)
+    end
 
-        for i in 0..key.length-1
-          h = to_int32(31 * h + key[i].ord)
-        end
+    def murmur_hash(key, seed)
+      @murmur_hash.call(key, seed)
+    end
 
-        h^seed
-      end
+    def legacy_hash(key, seed)
+      h = 0
 
-      #
-      # misc method to convert ruby number to int 32 since overflow is handled different to java
-      #
-      # @param number [number] ruby number value
-      #
-      # @return [int] returns the int 32 value of the provided number
-      def to_int32(number)
-        begin
-          sign = number < 0 ? -1 : 1
-          abs = number.abs
-          return 0 if abs == 0 || abs == Float::INFINITY
-        rescue
-          return 0
-        end
+      for i in 0..key.length-1
+        h = to_int32(31 * h + key[i].ord)
+      end
 
-        pos_int = sign * abs.floor
-        int_32bit = pos_int % 2**32
+      h^seed
+    end
 
-        return int_32bit - 2**32 if int_32bit >= 2**31
-        int_32bit
+    #
+    # misc method to convert ruby number to int 32 since overflow is handled different to java
+    #
+    # @param number [number] ruby number value
+    #
+    # @return [int] returns the int 32 value of the provided number
+    def to_int32(number)
+      begin
+        sign = number < 0 ? -1 : 1
+        abs = number.abs
+        return 0 if abs == 0 || abs == Float::INFINITY
+      rescue
+        return 0
       end
 
-      #
-      # returns the treatment for a bucket given the partitions
-      #
-      # @param bucket [number] bucket value
-      # @param parittions [object] array of partitions
-      #
-      # @return treatment [treatment] treatment value for this bucket and partitions
-      def get_treatment_for_key(bucket, partitions)
-        buckets_covered_thus_far = 0
-        partitions.each do |p|
-          unless p.is_empty?
-            buckets_covered_thus_far += p.size
-            return p.treatment if buckets_covered_thus_far >= bucket
-          end
-        end
+      pos_int = sign * abs.floor
+      int_32bit = pos_int % 2**32
 
-        return SplitIoClient::Engine::Models::Treatment::CONTROL
-      end
+      return int_32bit - 2**32 if int_32bit >= 2**31
+      int_32bit
+    end
 
-      #
-      # returns bucket value for the given hash value
-      #
-      # @param hash_value [string] hash value
-      #
-      # @return bucket [number] bucket number
-      def bucket(hash_value)
-        (hash_value.abs % 100) + 1
+    #
+    # returns the treatment for a bucket given the partitions
+    #
+    # @param bucket [number] bucket value
+    # @param parittions [object] array of partitions
+    #
+    # @return treatment [treatment] treatment value for this bucket and partitions
+    def get_treatment_for_key(bucket, partitions)
+      buckets_covered_thus_far = 0
+      partitions.each do |p|
+        unless p.is_empty?
+          buckets_covered_thus_far += p.size
+          return p.treatment if buckets_covered_thus_far >= bucket
+        end
       end
+
+      return SplitIoClient::Engine::Models::Treatment::CONTROL
+    end
+
+    #
+    # returns bucket value for the given hash value
+    #
+    # @param hash_value [string] hash value
+    #
+    # @return bucket [number] bucket number
+    def bucket(hash_value)
+      (hash_value.abs % 100) + 1
     end
   end
 end

data/lib/splitclient-rb/engine/parser/evaluator.rb

@@ -40,6 +40,7 @@ module SplitIoClient
           in_rollout = false
           key = keys[:bucketing_key] ? keys[:bucketing_key] : keys[:matching_key]
           legacy_algo = (split[:algo] == 1 || split[:algo] == nil) ? true : false
+          splitter = Splitter.new
 
           split[:conditions].each do |c|
             condition = SplitIoClient::Condition.new(c)
@@ -48,7 +49,7 @@ module SplitIoClient
 
             if !in_rollout && condition.type == SplitIoClient::Condition::TYPE_ROLLOUT
               if split[:trafficAllocation] < 100
-                bucket = Splitter.bucket(Splitter.count_hash(key, split[:trafficAllocationSeed].to_i, legacy_algo))
+                bucket = splitter.bucket(splitter.count_hash(key, split[:trafficAllocationSeed].to_i, legacy_algo))
 
                 if bucket >= split[:trafficAllocation]
                   return treatment_hash(Models::Label::NOT_IN_SPLIT, split[:defaultTreatment], split[:changeNumber])
@@ -67,7 +68,7 @@ module SplitIoClient
 
             next unless condition_matched
 
-            result = Splitter.get_treatment(key, split[:seed], condition.partitions, split[:algo])
+            result = splitter.get_treatment(key, split[:seed], condition.partitions, split[:algo])
 
             if result.nil?
               return treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber])

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '4.4.0'
+  VERSION = '4.5.1-dev'
 end

data/lib/splitclient-rb.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 require 'splitclient-rb/version'
 
 require 'splitclient-rb/exceptions/impressions_shutdown_exception'
@@ -78,6 +80,9 @@ require 'splitclient-rb/engine/models/label'
 require 'splitclient-rb/engine/models/treatment'
 require 'splitclient-rb/utilitites'
 
+# C extension
+require 'murmurhash/murmurhash_mri'
+
 module SplitIoClient
   def self.root
     File.dirname(__dir__)

data/splitclient-rb.gemspec

@@ -14,18 +14,30 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/splitio/ruby-client"
   spec.license       = "Apache 2.0"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|features|ext)/}) }
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  if defined?(JRUBY_VERSION)
+    spec.platform = 'java'
+    spec.files << 'ext/murmurhash/MurmurHash3.java'
+  else
+    spec.files.concat(%w(
+      ext/murmurhash/3_x86_32.c
+      ext/murmurhash/extconf.rb
+      ext/murmurhash/murmurhash.c
+      ext/murmurhash/murmurhash.h)
+    )
+    spec.extensions = ["ext/murmurhash/extconf.rb"]
+  end
+
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "webmock"
-  spec.add_development_dependency "byebug"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "allocation_stats"
 
@@ -35,5 +47,4 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "faraday", ">= 0.8"
   spec.add_runtime_dependency "net-http-persistent", "~> 2.9"
   spec.add_runtime_dependency "redis", ">= 3.2"
-  spec.add_runtime_dependency "digest-murmurhash", ">= 1.1"
 end

data/tasks/{console.rake → irb.rake}

@@ -1,4 +1,4 @@
 desc "Open an irb session preloaded with this library"
-task :console do
+task :irb do
   sh "irb -rubygems -I lib -r splitclient-rb.rb"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 4.4.0
+  version: 4.5.1.pre.dev
 platform: ruby
 authors:
 - Split Software
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-23 00:00:00.000000000 Z
+date: 2018-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,21 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: webmock
+  name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,21 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -220,26 +192,13 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
-- !ruby/object:Gem::Dependency
-  name: digest-murmurhash
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.1'
 description: Ruby client for using split SDK.
 email:
 - pato@split.io
 executables:
 - splitio
-extensions: []
+extensions:
+- ext/murmurhash/extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -250,8 +209,14 @@ files:
 - NEWS
 - README.md
 - Rakefile
-- console
 - exe/splitio
+- ext/murmurhash/3_x86_32.c
+- ext/murmurhash/extconf.rb
+- ext/murmurhash/murmurhash.c
+- ext/murmurhash/murmurhash.h
+- lib/murmurhash/base.rb
+- lib/murmurhash/murmurhash.jar
+- lib/murmurhash/murmurhash_mri.rb
 - lib/splitclient-rb.rb
 - lib/splitclient-rb/cache/adapters/memory_adapter.rb
 - lib/splitclient-rb/cache/adapters/memory_adapters/map_adapter.rb
@@ -328,12 +293,10 @@ files:
 - lib/splitclient-rb/split_factory_builder.rb
 - lib/splitclient-rb/utilitites.rb
 - lib/splitclient-rb/version.rb
-- runTests
 - splitclient-rb.gemspec
 - splitio.yml.example
 - tasks/benchmark_get_treatment.rake
-- tasks/benchmark_hashing_algorithm.rake
-- tasks/console.rake
+- tasks/irb.rake
 - tasks/rspec.rake
 homepage: https://github.com/splitio/ruby-client
 licenses:
@@ -350,12 +313,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Ruby client for split SDK.

data/console

@@ -1,2 +0,0 @@
-#!/bin/bash
-bundle exec rake console

data/runTests

@@ -1,2 +0,0 @@
-#!/bin/bash
-SPLITCLIENT_ENV=test bundle exec rspec spec

data/tasks/benchmark_hashing_algorithm.rake

@@ -1,51 +0,0 @@
-require 'benchmark'
-require 'digest/murmurhash'
-
-desc 'Benchmark murmur32 hashing algorithm'
-
-task :benchmark_hashing_algorithm do
-  iterations = 200_000
-  key = SecureRandom.uuid
-
-  Benchmark.bmbm do |x|
-    x.report('MurmurHash1') do
-      iterations.times { Digest::MurmurHash1.rawdigest(key) }
-    end
-
-    x.report('MurmurHash2') do
-      iterations.times { Digest::MurmurHash2.rawdigest(key) }
-    end
-
-    x.report('MurmurHash2A') do
-      iterations.times { Digest::MurmurHash2A.rawdigest(key) }
-    end
-
-    x.report('LegacyHash') do
-      iterations.times { legacy_hash(key, 123) }
-    end
-  end
-end
-
-def legacy_hash(key, seed)
-  h = 0
-  for i in 0..key.length-1
-    h = to_int32(31 * h + key[i].ord)
-  end
-  h^seed
-end
-
-def to_int32(number)
-  begin
-    sign = number < 0 ? -1 : 1
-    abs = number.abs
-    return 0 if abs == 0 || abs == Float::INFINITY
-  rescue
-    return 0
-  end
-
-  pos_int = sign * abs.floor
-  int_32bit = pos_int % 2**32
-
-  return int_32bit - 2**32 if int_32bit >= 2**31
-  int_32bit
-end