splitclient-rb 4.5.1-java

data/lib/murmurhash/murmurhash_mri.rb

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

data/lib/splitclient-rb.rb

@@ -0,0 +1,90 @@
+require 'forwardable'
+
+require 'splitclient-rb/version'
+
+require 'splitclient-rb/exceptions/impressions_shutdown_exception'
+require 'splitclient-rb/exceptions/sdk_blocker_timeout_expired_exception'
+require 'splitclient-rb/cache/routers/impression_router'
+require 'splitclient-rb/cache/adapters/memory_adapters/map_adapter'
+require 'splitclient-rb/cache/adapters/memory_adapters/queue_adapter'
+require 'splitclient-rb/cache/adapters/memory_adapter'
+require 'splitclient-rb/cache/adapters/redis_adapter'
+require 'splitclient-rb/cache/repositories/repository'
+require 'splitclient-rb/cache/repositories/segments_repository'
+require 'splitclient-rb/cache/repositories/splits_repository'
+require 'splitclient-rb/cache/repositories/events_repository'
+require 'splitclient-rb/cache/repositories/impressions_repository'
+require 'splitclient-rb/cache/repositories/events/memory_repository'
+require 'splitclient-rb/cache/repositories/events/redis_repository'
+require 'splitclient-rb/cache/repositories/impressions/memory_repository'
+require 'splitclient-rb/cache/repositories/impressions/redis_repository'
+require 'splitclient-rb/cache/repositories/metrics_repository'
+require 'splitclient-rb/cache/repositories/metrics/memory_repository'
+require 'splitclient-rb/cache/repositories/metrics/redis_repository'
+require 'splitclient-rb/cache/senders/impressions_formatter'
+require 'splitclient-rb/cache/senders/impressions_sender'
+require 'splitclient-rb/cache/senders/metrics_sender'
+require 'splitclient-rb/cache/senders/events_sender'
+require 'splitclient-rb/cache/stores/sdk_blocker'
+require 'splitclient-rb/cache/stores/segment_store'
+require 'splitclient-rb/cache/stores/split_store'
+
+require 'splitclient-rb/localhost_utils'
+require 'splitclient-rb/clients/localhost_split_client'
+require 'splitclient-rb/clients/split_client'
+require 'splitclient-rb/managers/localhost_split_manager'
+require 'splitclient-rb/managers/split_manager'
+require 'splitclient-rb/split_factory'
+require 'splitclient-rb/split_factory_builder'
+require 'splitclient-rb/localhost_split_factory'
+require 'splitclient-rb/split_config'
+
+require 'splitclient-rb/engine/api/faraday_middleware/gzip'
+require 'splitclient-rb/engine/api/client'
+require 'splitclient-rb/engine/api/impressions'
+require 'splitclient-rb/engine/api/metrics'
+require 'splitclient-rb/engine/api/segments'
+require 'splitclient-rb/engine/api/splits'
+require 'splitclient-rb/engine/api/events'
+require 'splitclient-rb/engine/parser/condition'
+require 'splitclient-rb/engine/parser/partition'
+require 'splitclient-rb/engine/parser/split_adapter'
+require 'splitclient-rb/engine/parser/evaluator'
+require 'splitclient-rb/engine/matchers/combiners'
+require 'splitclient-rb/engine/matchers/combining_matcher'
+require 'splitclient-rb/engine/matchers/all_keys_matcher'
+require 'splitclient-rb/engine/matchers/negation_matcher'
+require 'splitclient-rb/engine/matchers/user_defined_segment_matcher'
+require 'splitclient-rb/engine/matchers/whitelist_matcher'
+require 'splitclient-rb/engine/matchers/equal_to_matcher'
+require 'splitclient-rb/engine/matchers/greater_than_or_equal_to_matcher'
+require 'splitclient-rb/engine/matchers/less_than_or_equal_to_matcher'
+require 'splitclient-rb/engine/matchers/between_matcher'
+require 'splitclient-rb/engine/matchers/set_matcher'
+require 'splitclient-rb/engine/matchers/part_of_set_matcher'
+require 'splitclient-rb/engine/matchers/equal_to_set_matcher'
+require 'splitclient-rb/engine/matchers/contains_any_matcher'
+require 'splitclient-rb/engine/matchers/contains_all_matcher'
+require 'splitclient-rb/engine/matchers/starts_with_matcher'
+require 'splitclient-rb/engine/matchers/ends_with_matcher'
+require 'splitclient-rb/engine/matchers/contains_matcher'
+require 'splitclient-rb/engine/matchers/dependency_matcher'
+require 'splitclient-rb/engine/matchers/equal_to_boolean_matcher'
+require 'splitclient-rb/engine/matchers/equal_to_matcher'
+require 'splitclient-rb/engine/matchers/matches_string_matcher'
+require 'splitclient-rb/engine/evaluator/splitter'
+require 'splitclient-rb/engine/metrics/metrics'
+require 'splitclient-rb/engine/metrics/binary_search_latency_tracker'
+require 'splitclient-rb/engine/models/split'
+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__)
+  end
+end

data/lib/splitclient-rb/cache/adapters/memory_adapter.rb

@@ -0,0 +1,12 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      # Memory adapter can have different implementations, this class is used as a delegator to
+      # this implementations
+      class MemoryAdapter < SimpleDelegator
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/adapters/memory_adapters/map_adapter.rb

@@ -0,0 +1,133 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      module MemoryAdapters
+        # Memory adapter implementation, which stores everything inside thread-safe Map
+        class MapAdapter
+          def initialize
+            @map = Concurrent::Map.new
+          end
+
+          def clear(_ = nil)
+            initialize
+          end
+
+          # Map
+          def initialize_map(key)
+            @map[key] = Concurrent::Map.new
+          end
+
+          def add_to_map(key, field, value)
+            initialize_map(key) unless @map[key]
+
+            @map[key].put(field, value)
+          end
+
+          def find_in_map(key, field)
+            return nil if @map[key].nil?
+
+            @map[key].get(field)
+          end
+
+          def delete_from_map(key, fields)
+            if fields.is_a? Array
+              fields.each { |field| @map[key].delete(field) }
+            else
+              @map[key].delete(fields)
+            end
+          end
+
+          def in_map?(key, field)
+            return false if @map[key].nil?
+
+            @map[key].key?(field)
+          end
+
+          def map_keys(key)
+            @map[key].keys
+          end
+
+          def get_map(key)
+            @map[key]
+          end
+
+          # String
+          def string(key)
+            @map[key]
+          end
+
+          def set_string(key, str)
+            @map[key] = str
+          end
+
+          def find_strings_by_prefix(prefix)
+            @map.keys.select { |str| str.start_with? prefix }
+          end
+
+          def multiple_strings(keys)
+            keys.each_with_object({}) do |key, memo|
+              memo[key] = string(key)
+            end
+          end
+
+          # Bool
+          def set_bool(key, val)
+            @map[key] = val
+          end
+
+          def bool(key)
+            @map[key]
+          end
+
+          # Set
+          alias_method :initialize_set, :initialize_map
+          alias_method :get_set, :map_keys
+          alias_method :delete_from_set, :delete_from_map
+          alias_method :in_set?, :in_map?
+          alias_method :find_sets_by_prefix, :find_strings_by_prefix
+
+          def add_to_set(key, values)
+            if values.is_a? Array
+              values.each { |value| add_to_map(key, value, 1) }
+            else
+              add_to_map(key, values, 1)
+            end
+          end
+
+          def get_all_from_set(key)
+            @map[key].keys
+          end
+
+          def union_sets(set_keys)
+            array = set_keys.each_with_object([]) do |key, memo|
+              memo << get_set(key)
+            end.flatten
+
+            Set.new(array)
+          end
+
+          # General
+          def exists?(key)
+            !@map[key].nil?
+          end
+
+          def delete(key)
+            if key.is_a? Array
+              key.each { |k| @map.delete(k) }
+            else
+              @map.delete(key)
+            end
+          end
+
+          # This method is used in Redis adapter
+          # "stubbing" it here to keep the interface
+          def pipelined(&block)
+            block.call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/adapters/memory_adapters/queue_adapter.rb

@@ -0,0 +1,44 @@
+module SplitIoClient
+  module Cache
+    module Adapters
+      module MemoryAdapters
+        # Memory adapter implementation, which stores everything inside queue
+        class QueueAdapter
+          def initialize(max_size)
+            @max_size = max_size
+            @queue = Queue.new
+            @current_size = Concurrent::AtomicFixnum.new(0)
+          end
+
+          def clear(_ = nil)
+            @queue = Queue.new
+            @current_size.value = 0
+          end
+
+          # Adds data to queue in non-blocking mode
+          def add_to_queue(data)
+            fail ThreadError if @current_size.value >= @max_size
+
+            @queue.push(data)
+
+            @current_size.increment
+          end
+
+          # Get all items from the queue
+          def clear
+            items = []
+
+            loop do
+              items << @queue.pop(true)
+
+              @current_size.decrement
+            end
+
+          rescue ThreadError
+            items
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/adapters/redis_adapter.rb

@@ -0,0 +1,165 @@
+require 'json'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      # Redis adapter used to provide interface to Redis
+      class RedisAdapter
+        SCAN_SLICE = 5000
+
+        attr_reader :redis
+
+        def initialize(redis_url)
+          connection = redis_url.is_a?(Hash) ? redis_url : { url: redis_url }
+
+          @redis = Redis.new(connection)
+        end
+
+        # Map
+        def initialize_map(key)
+          # No need to initialize hash/map in Redis
+        end
+
+        def add_to_map(key, field, value)
+          @redis.hset(key, field, value)
+        end
+
+        def find_in_map(key, field)
+          @redis.hget(key, field)
+        end
+
+        def delete_from_map(key, field)
+          @redis.hdel(key, field)
+        end
+
+        def in_map?(key, field)
+          @redis.hexists(key, field)
+        end
+
+        def map_keys(key)
+          @redis.hkeys(key)
+        end
+
+        def get_map(key)
+          @redis.hgetall(key)
+        end
+
+        # String
+        def string(key)
+          @redis.get(key)
+        end
+
+        def set_string(key, str)
+          @redis.set(key, str)
+        end
+
+        def find_strings_by_prefix(prefix)
+          memo = { items: [], cursor: 0 }
+
+          loop do
+            memo[:cursor], items = @redis.scan(memo[:cursor], match: "#{prefix}*", count: SCAN_SLICE)
+
+            memo[:items].push(*items)
+
+            break if memo[:cursor] == '0'
+          end
+
+          memo[:items]
+        end
+
+        def multiple_strings(keys)
+          Hash[keys.zip(@redis.mget(keys))]
+        end
+
+        def append_to_string(key, val)
+          @redis.append(key, val)
+        end
+
+        # Bool
+        def set_bool(key, val)
+          @redis.set(key, val.to_s)
+        end
+
+        def bool(key)
+          @redis.get(key) == 'true'
+        end
+
+        # Set
+        alias_method :initialize_set, :initialize_map
+        alias_method :find_sets_by_prefix, :find_strings_by_prefix
+
+        def add_to_set(key, val)
+          @redis.sadd(key, val)
+        end
+
+        def delete_from_set(key, val)
+          @redis.srem(key, val)
+        end
+
+        def get_set(key)
+          @redis.smembers(key)
+        end
+
+        def in_set?(key, val)
+          @redis.sismember(key, val)
+        end
+
+        def get_all_from_set(key)
+          @redis.smembers(key)
+        end
+
+        def union_sets(set_keys)
+          return [] if set_keys == []
+
+          @redis.sunion(set_keys)
+        end
+
+        def random_set_elements(key, count)
+          @redis.srandmember(key, count)
+        end
+
+        # Queue
+        def add_to_queue(key, val)
+          @redis.rpush(key, val)
+        end
+
+        def get_from_queue(key, count)
+          items = @redis.lrange(key, 0, count - 1)
+          fetched_count = items.size
+          items_to_remove = (fetched_count == count) ? count : fetched_count
+
+          @redis.ltrim(key, items_to_remove, -1)
+
+          items
+        end
+
+        # General
+        def exists?(key)
+          @redis.exists(key)
+        end
+
+        def delete(key)
+          return nil if key == []
+
+          @redis.del(key)
+        end
+
+        def inc(key, inc = 1)
+          @redis.incrby(key, inc)
+        end
+
+        def pipelined(&block)
+          @redis.pipelined do
+            block.call
+          end
+        end
+
+        def clear(prefix)
+          keys = @redis.keys("#{prefix}*")
+
+          keys.map { |key| @redis.del(key) }
+        end
+      end
+    end
+  end
+end