splitclient-rb 2.0.1 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15187969c2e35ddd3cfaf21e25f0cdbbf8daa826
-  data.tar.gz: 543a3ca07e3724d5dace9b920bddb9adbdc33046
+  metadata.gz: ae8492b8f79d39cda6b4c52bb8300c8d7374fef4
+  data.tar.gz: '09129f27b81bd42cea7731786f62b4bffdbc5c96'
 SHA512:
-  metadata.gz: 20c99dc8e41344b8afc83bddf87cd20d653b34936aeed35c4a9717e3d2656eaa4a6b7b787795d95b6291bd61dc9754f5ae0ec6525d06490866f9cf735c597ee3
-  data.tar.gz: f2a7947a3de5d026232156061916f49154293dd90d425486f02c9449f16d48edb9df09f244603a471f669ff7811f6a10c1c34515cfd053faa19554886b6fe521
+  metadata.gz: b5595aecddeef4d878fd02f7748b0e8a97cfe9870495f8e0fee0198ec7db71673c379f995154e80f1f6cc34a6c411c047f6cacf76a3204d4c9681baf566687bd
+  data.tar.gz: fc242d04f2fd5fb1590239d212da8e427a47cc9f0d2cd069c107b84d78fa64e47d10e05049b81e54bd4a8c00503f47885c4238b8c89c9818b1b493c002b1b3e0

data/CHANGES.txt

@@ -1,3 +1,15 @@
+3.0.2
+- add ability to provide different bucketing/matching keys
+
+3.0.1
+- fix segments not deleting from the cache
+
+3.0.0
+- add new caching interface
+- add replaceable adapters to store cache in
+- add first cache adapter: MemoryAdapter
+- refactoring
+
 2.0.1
 - Supress warnings cause by Net::HTTP when it already exists.
 

data/NEWS

@@ -1,3 +1,7 @@
+3.0.2
+
+now support also client.get_treatment( { :matching_key = 'bb' , "bucketing_key = ''}, ....)
+
 2.0.1
 
 No news for this release

data/README.md

@@ -100,23 +100,40 @@ The following values can be customized
 **impressions_refresh_rate** : The SDK sends information on who got what treatment at what time back to Split servers to power analytics. This parameter controls how often this data is sent to Split servers in seconds
 *default value* = 60
 
+**debug_enabled** : Enables extra logging
+*default value* = false
+
+**transport_debug_enabled** : Enables extra transport logging
+*default value* = false
+
 **logger** : default logger for messages and errors
 *default value* : Ruby logger class set to STDOUT
 
+**block_until_ready** : The SDK will block your app for provided amount of seconds until it's ready. If timeout expires `SplitIoClient::SDKBlockerTimeoutExpiredException` will be thrown. If `false` provided, then SDK would run in non-blocking mode
+*default value* : false
+
 Example
 ```ruby
-options = {base_uri: 'https://my.app.api/',
-           local_store: Rails.cache,
-           connection_timeout: 10,
-           read_timeout: 5,
-           features_refresh_rate: 120,
-           segments_refresh_rate: 120,
-           metrics_refresh_rate: 360,
-           impressions_refresh_rate: 360,
-           logger: Logger.new('logfile.log')}
-
-split_client = SplitIoClient::SplitFactory.new("your_api_key", options).client
+options = {
+  base_uri: 'https://my.app.api/',
+  local_store: Rails.cache,
+  connection_timeout: 10,
+  read_timeout: 5,
+  features_refresh_rate: 120,
+  segments_refresh_rate: 120,
+  metrics_refresh_rate: 360,
+  impressions_refresh_rate: 360,
+  logger: Logger.new('logfile.log'),
+  block_until_ready: 5
+}
+begin
+  split_client = SplitIoClient::SplitFactory.new("your_api_key", options).client
+rescue SplitIoClient::SDKBlockerTimeoutExpiredException
+  # Some arbitrary actions
+end
 ```
+This begin-rescue-end block is optional, you might want to use it to catch timeout expired exception and apply some logic here.
+
 ### Execution
 ---
 In your application code you just need to call the get_treatment method with the required parameters for key and feature name
@@ -131,6 +148,23 @@ if split_client.get_treatment('employee_user_01','view_main_list', {age: 35})
 end
 ```
 
+Also, you can use different keys for actually getting treatment and sending impressions to the server:
+```ruby
+split_client.get_treatment({ matching_key: 'user_id', bucketing_key: 'private_user_id' },'feature_name', {attr: 'val'})
+```
+When it might be useful? Say, you have a user browsing your website and not signed up yet. You assign some internal id to that user (i.e. bucketing_key) and after user signs up you assign him a matching_key.
+By doing this you can provide both anonymous and signed up user with the same treatment.
+
+`bucketing_key` may be `nil` in that case `matching_key` would be used as a key, so calling
+```ruby
+split_client.get_treatment({ matching_key: 'user_id' },'feature_name', {attr: 'val'})
+```
+Is exactly the same as calling
+```ruby
+split_client.get_treatment('user_id' ,'feature_name', {attr: 'val'})
+```
+`bucketing_key` must not be nil
+
 Also you can use the split manager:
 
 ```ruby

data/lib/cache/adapters/adapter.rb

@@ -0,0 +1,23 @@
+module SplitIoClient
+  module Cache
+    module Adapters
+      class Adapter
+        def set
+          raise NoMethodError
+        end
+
+        def get
+          raise NoMethodError
+        end
+
+        def remove
+          raise NoMethodError
+        end
+
+        def key?
+          raise NoMethodError
+        end
+      end
+    end
+  end
+end

data/lib/cache/adapters/memory_adapter.rb

@@ -0,0 +1,46 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      class MemoryAdapter < Adapter
+        def initialize
+          @map = Concurrent::Map.new
+        end
+
+        # Map
+        def [](key)
+          @map[key]
+        end
+
+        def []=(key, obj)
+          @map[key] = obj
+        end
+
+        def initialize_map(key)
+          @map[key] = Concurrent::Map.new
+        end
+
+        def add_to_map(key, map_key, map_value)
+          @map[key].put(map_key, map_value)
+        end
+
+        def find_in_map(key, map_key)
+          return nil if @map[key].nil?
+
+          @map[key].get(map_key)
+        end
+
+        def delete_from_map(key, map_key)
+          @map[key].delete(map_key)
+        end
+
+        def in_map?(key, map_key)
+          return false if @map[key].nil?
+
+          @map[key].key?(map_key)
+        end
+      end
+    end
+  end
+end

data/lib/cache/repositories/repository.rb

@@ -0,0 +1,25 @@
+module SplitIoClient
+  module Cache
+    class Repository
+      def initialize(adapter)
+        @adapter = adapter
+
+        @adapter[namespace_key('ready')] = false
+      end
+
+      def []=(key, obj)
+        @adapter[namespace_key(key)] = obj
+      end
+
+      def [](key)
+        @adapter[namespace_key(key)]
+      end
+
+      protected
+
+      def namespace_key(key)
+        "repository_#{key}"
+      end
+    end
+  end
+end

data/lib/cache/repositories/segments_repository.rb

@@ -0,0 +1,52 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      class SegmentsRepository < Repository
+        def add_to_segment(segment)
+          name = segment[:name]
+
+          @adapter.initialize_map(namespace_key("segments:#{name}")) if @adapter[namespace_key("segments:#{name}")].nil?
+
+          add_keys(name, segment[:added])
+          remove_keys(name, segment[:removed])
+        end
+
+        def get_segment_keys(name)
+          @adapter[namespace_key("segments:#{name}")]
+        end
+
+        def in_segment?(name, key)
+          @adapter.in_map?(namespace_key("segments:#{name}"), key)
+        end
+
+        def used_segment_names
+          @adapter['splits_repository_used_segment_names'].keys
+        end
+
+        def set_change_number(name, last_change)
+          @adapter.initialize_map(namespace_key('changes')) if @adapter[namespace_key('changes')].nil?
+
+          @adapter.add_to_map(namespace_key('changes'), name, last_change)
+        end
+
+        def get_change_number(name)
+          @adapter.find_in_map(namespace_key('changes'), name) || -1
+        end
+
+        private
+
+        def namespace_key(key)
+          "segments_repository_#{key}"
+        end
+
+        def add_keys(name, keys)
+          keys.each { |key| @adapter.add_to_map(namespace_key("segments:#{name}"), key, 1) }
+        end
+
+        def remove_keys(name, keys)
+          keys.each { |key| @adapter.delete_from_map(namespace_key("segments:#{name}"), key) }
+        end
+      end
+    end
+  end
+end

data/lib/cache/repositories/splits_repository.rb

@@ -0,0 +1,51 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      class SplitsRepository < Repository
+        def initialize(adapter)
+          @adapter = adapter
+
+          @adapter[namespace_key('last_change')] = -1
+          @adapter.initialize_map(namespace_key('splits'))
+          @adapter.initialize_map(namespace_key('used_segment_names'))
+        end
+
+        def add_split(split)
+          split_without_name = split.select { |k, _| k != :name }
+
+          @adapter.add_to_map(namespace_key('splits'), split[:name], split_without_name)
+        end
+
+        def remove_split(name)
+          @adapter.add_to_map(namespace_key('splits'), name, nil)
+        end
+
+        def get_split(name)
+          @adapter.find_in_map(namespace_key('splits'), name)
+        end
+
+        def set_change_number(since)
+          @adapter[namespace_key('last_change')] = since
+        end
+
+        def get_change_number
+          @adapter[namespace_key('last_change')]
+        end
+
+        def set_segment_names(names)
+          return if names.nil? || names.empty?
+
+          names.each do |name|
+            @adapter.add_to_map(namespace_key('used_segment_names'), name, 1)
+          end
+        end
+
+        private
+
+        def namespace_key(key)
+          "splits_repository_#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/cache/stores/sdk_blocker.rb

@@ -0,0 +1,47 @@
+require 'thread'
+require 'timeout'
+
+module SplitIoClient
+  module Cache
+    module Stores
+      class SDKBlocker
+        attr_reader :splits_ready
+        attr_writer :splits_thread, :segments_thread
+
+        def initialize(config)
+          @config = config
+
+          @splits_ready = false
+          @segments_ready = false
+        end
+
+        def splits_ready!
+          @splits_ready = true
+        end
+
+        def segments_ready!
+          @segments_ready = true
+        end
+
+        def block
+          begin
+            Timeout::timeout(@config.block_until_ready) do
+              sleep 0.1 until ready?
+              sleep 0.1 until ready?
+            end
+          rescue Timeout::Error
+            fail SDKBlockerTimeoutExpiredException, 'SDK start up timeout expired'
+          end
+
+          @config.logger.info('SplitIO SDK is ready')
+          @splits_thread.run
+          @segments_thread.run
+        end
+
+        def ready?
+          @splits_ready && @segments_ready
+        end
+      end
+    end
+  end
+end

data/lib/cache/stores/segment_store.rb

@@ -0,0 +1,71 @@
+module SplitIoClient
+  module Cache
+    module Stores
+      class SegmentStore
+        attr_reader :segments_repository
+
+        def initialize(segments_repository, config, api_key, metrics, sdk_blocker = nil)
+          @segments_repository = segments_repository
+          @config = config
+          @api_key = api_key
+          @metrics = metrics
+          @sdk_blocker = sdk_blocker
+        end
+
+        def call
+          if ENV['SPLITCLIENT_ENV'] == 'test'
+            store_segments
+          else
+            @sdk_blocker.segments_thread = Thread.new do
+              @config.block_until_ready ? blocked_store : unblocked_store
+            end
+          end
+        end
+
+        private
+
+        def blocked_store
+          loop do
+            next unless @sdk_blocker.splits_ready
+
+            store_segments
+            @config.logger.debug("Segment names: #{@segments_repository.used_segment_names.to_a}") if @config.debug_enabled
+
+            unless @sdk_blocker.ready?
+              @sdk_blocker.segments_ready!
+              @config.logger.info('segments are ready')
+            end
+
+            sleep_for = random_interval(@config.segments_refresh_rate)
+            @config.logger.debug("Segments store is sleeping for: #{sleep_for} seconds") if @config.debug_enabled
+            sleep(sleep_for)
+          end
+        end
+
+        def unblocked_store
+          loop do
+            store_segments
+
+            sleep(random_interval(@config.segments_refresh_rate))
+          end
+        end
+
+        def store_segments
+          segments_api.store_segments_by_names(@segments_repository.used_segment_names)
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
+
+        def random_interval(interval)
+          random_factor = Random.new.rand(50..100) / 100.0
+
+          interval * random_factor
+        end
+
+        def segments_api
+          SplitIoClient::Api::Segments.new(@api_key, @config, @metrics, @segments_repository)
+        end
+      end
+    end
+  end
+end

data/lib/cache/stores/split_store.rb

@@ -0,0 +1,64 @@
+module SplitIoClient
+  module Cache
+    module Stores
+      class SplitStore
+        attr_reader :splits_repository
+
+        def initialize(splits_repository, config, api_key, metrics, sdk_blocker = nil)
+          @splits_repository = splits_repository
+          @config = config
+          @api_key = api_key
+          @metrics = metrics
+          @sdk_blocker = sdk_blocker
+        end
+
+        def call
+          if ENV['SPLITCLIENT_ENV'] == 'test'
+            store_splits
+          else
+            @sdk_blocker.splits_thread = Thread.new do
+              loop do
+                store_splits
+
+                sleep(random_interval(@config.features_refresh_rate))
+              end
+            end
+          end
+        end
+
+        private
+
+        def store_splits
+          data = splits_since(@splits_repository.get_change_number)
+
+          data[:splits] && data[:splits].each do |split|
+            @splits_repository.add_split(split)
+          end
+
+          @splits_repository.set_segment_names(data[:segment_names])
+          @splits_repository.set_change_number(data[:till])
+
+          @config.logger.debug("segments seen(#{data[:segment_names].length()}): #{data[:segment_names].to_a}") if @config.debug_enabled
+
+          if @config.block_until_ready && !@sdk_blocker.ready?
+            @sdk_blocker.splits_ready!
+            @config.logger.info('splits are ready')
+          end
+          
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
+
+        def random_interval(interval)
+          random_factor = Random.new.rand(50..100) / 100.0
+
+          interval * random_factor
+        end
+
+        def splits_since(since)
+          SplitIoClient::Api::Splits.new(@api_key, @config, @metrics).since(since)
+        end
+      end
+    end
+  end
+end