splitclient-rb 4.5.1-java

data/lib/splitclient-rb/cache/senders/metrics_sender.rb

@@ -0,0 +1,49 @@
+module SplitIoClient
+  module Cache
+    module Senders
+      class MetricsSender
+        def initialize(metrics_repository, config, api_key)
+          @metrics_repository = metrics_repository
+          @config = config
+          @api_key = api_key
+        end
+
+        def call
+          return if ENV['SPLITCLIENT_ENV'] == 'test'
+
+          metrics_thread
+
+          if defined?(PhusionPassenger)
+            PhusionPassenger.on_event(:starting_worker_process) do |forked|
+              metrics_thread if forked
+            end
+          end
+        end
+
+        private
+
+        def metrics_thread
+          @config.threads[:metrics_sender] = Thread.new do
+            @config.logger.info('Starting metrics service')
+
+            loop do
+              post_metrics
+
+              sleep(SplitIoClient::Utilities.randomize_interval(@config.metrics_refresh_rate))
+            end
+          end
+        end
+
+        def post_metrics
+          metrics_client.post
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
+
+        def metrics_client
+          SplitIoClient::Api::Metrics.new(@api_key, @config, @metrics_repository)
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/stores/sdk_blocker.rb

@@ -0,0 +1,48 @@
+require 'thread'
+require 'timeout'
+
+module SplitIoClient
+  module Cache
+    module Stores
+      class SDKBlocker
+        attr_reader :splits_repository
+        attr_writer :splits_thread, :segments_thread
+
+        def initialize(config, splits_repository, segments_repository)
+          @config = config
+          @splits_repository = splits_repository
+          @segments_repository = segments_repository
+
+          @splits_repository.not_ready!
+          @segments_repository.not_ready!
+        end
+
+        def splits_ready!
+          @splits_repository.ready!
+        end
+
+        def segments_ready!
+          @segments_repository.ready!
+        end
+
+        def block
+          begin
+            Timeout::timeout(@config.block_until_ready) do
+              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_repository.ready? && @segments_repository.ready?
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/stores/segment_store.rb

@@ -0,0 +1,82 @@
+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
+            segments_thread
+
+            if defined?(PhusionPassenger)
+              PhusionPassenger.on_event(:starting_worker_process) do |forked|
+                segments_thread if forked
+              end
+            end
+          end
+        end
+
+        private
+
+        def segments_thread
+          @config.threads[:segment_store] = @sdk_blocker.segments_thread = Thread.new do
+            @config.logger.info('Starting segments fetcher service')
+            @config.block_until_ready > 0 ? blocked_store : unblocked_store
+          end
+        end
+
+        def blocked_store
+          loop do
+            next unless @sdk_blocker.splits_repository.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/splitclient-rb/cache/stores/split_store.rb

@@ -0,0 +1,97 @@
+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
+            splits_thread
+
+            if defined?(PhusionPassenger)
+              PhusionPassenger.on_event(:starting_worker_process) do |forked|
+                splits_thread if forked
+              end
+            end
+          end
+        end
+
+        private
+
+        def splits_thread
+          @config.threads[:split_store] = @sdk_blocker.splits_thread = Thread.new do
+            @config.logger.info('Starting splits fetcher service')
+            loop do
+              store_splits
+
+              sleep(random_interval(@config.features_refresh_rate))
+            end
+          end
+        end
+
+        def store_splits
+          data = splits_since(@splits_repository.get_change_number)
+
+          data[:splits] && data[:splits].each do |split|
+            add_split_unless_archived(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 > 0 && !@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
+
+        def add_split_unless_archived(split)
+          if Engine::Models::Split.archived?(split)
+            @config.logger.debug("Seeing archived split #{split[:name]}") if @config.debug_enabled
+
+            remove_archived_split(split)
+          else
+            store_split(split)
+          end
+        end
+
+        def remove_archived_split(split)
+          @config.logger.debug("removing split from store(#{split})") if @config.debug_enabled
+
+          @splits_repository.remove_split(split[:name])
+        end
+
+        def store_split(split)
+          @config.logger.debug("storing split (#{split[:name]})") if @config.debug_enabled
+
+          @splits_repository.add_split(split)
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/clients/localhost_split_client.rb

@@ -0,0 +1,92 @@
+module SplitIoClient
+  class LocalhostSplitClient
+    include SplitIoClient::LocalhostUtils
+
+    #
+    # variables to if the sdk is being used in localhost mode and store the list of features
+    attr_reader :localhost_mode
+    attr_reader :localhost_mode_features
+
+    #
+    # Creates a new split client instance that reads from the given splits file
+    #
+    # @param splits_file [File] file that contains some splits
+    #
+    # @return [LocalhostSplitIoClient] split.io localhost client instance
+    def initialize(splits_file, reload_rate = nil)
+      @localhost_mode = true
+      @localhost_mode_features = []
+      load_localhost_mode_features(splits_file, reload_rate)
+    end
+
+    #
+    # method that returns the sdk gem version
+    #
+    # @return [string] version value for this sdk
+    def self.sdk_version
+      'ruby-'+SplitIoClient::VERSION
+    end
+
+    def get_treatments(key, split_names, attributes = nil)
+      split_names.each_with_object({}) do |name, memo|
+        puts "name #{name} memo #{memo}"
+        memo.merge!(name => get_treatment(key, name, attributes))
+      end
+    end
+
+    #
+    # obtains the treatment for a given feature
+    #
+    # @param id [string] user id
+    # @param feature [string] name of the feature that is being validated
+    #
+    # @return [Treatment]  treatment constant value
+    def get_treatment(id, feature, attributes = nil)
+      unless id
+        @config.logger.warn('id was null for feature: ' + feature)
+        return SplitIoClient::Engine::Models::Treatment::CONTROL
+      end
+
+      unless feature
+        @config.logger.warn('feature was null for id: ' + id)
+        return SplitIoClient::Engine::Models::Treatment::CONTROL
+      end
+
+      result = get_localhost_treatment(feature)
+    end
+
+    def track
+    end
+
+    private
+
+    #
+    # auxiliary method to get the treatments avoding exceptions
+    #
+    # @param id [string] user id
+    # @param feature [string] name of the feature that is being validated
+    #
+    # @return [Treatment]  tretment constant value
+    def get_treatment_without_exception_handling(id, feature, attributes = nil)
+      get_treatment(id, feature, attributes)
+    end
+
+    #
+    # method to check if the sdk is running in localhost mode based on api key
+    #
+    # @return [boolean] True if is in localhost mode, false otherwise
+    def is_localhost_mode?
+      true
+    end
+
+    #
+    # method to check the treatment for the given feature in localhost mode
+    #
+    # @return [boolean] true if the feature is available in localhost mode, false otherwise
+    def get_localhost_treatment(feature)
+      treatment = @localhost_mode_features.select { |h| h[:feature] == feature }.last || {}
+
+      treatment[:treatment] || SplitIoClient::Engine::Models::Treatment::CONTROL
+    end
+  end
+end

data/lib/splitclient-rb/clients/split_client.rb

@@ -0,0 +1,214 @@
+module SplitIoClient
+  class SplitClient
+    #
+    # Creates a new split client instance that connects to split.io API.
+    #
+    # @param api_key [String] the API key for your split account
+    #
+    # @return [SplitIoClient] split.io client instance
+    def initialize(api_key, config = {}, adapter = nil, splits_repository, segments_repository, impressions_repository, metrics_repository, events_repository)
+      @config = config
+
+      @splits_repository = splits_repository
+      @segments_repository = segments_repository
+      @impressions_repository = impressions_repository
+      @metrics_repository = metrics_repository
+      @events_repository = events_repository
+
+      @adapter = adapter
+    end
+
+    def get_treatments(key, split_names, attributes = nil)
+      bucketing_key, matching_key = keys_from_key(key)
+      evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, true)
+
+      treatments_labels_change_numbers =
+        @splits_repository.get_splits(split_names).each_with_object({}) do |(name, data), memo|
+          memo.merge!(name => get_treatment(key, name, attributes, data, false, true, evaluator))
+        end
+
+      if @config.impressions_queue_size > 0
+        time = (Time.now.to_f * 1000.0).to_i
+        @impressions_repository.add_bulk(
+          matching_key, bucketing_key, treatments_labels_change_numbers, time
+        )
+
+        route_impressions(split_names, matching_key, bucketing_key, time, treatments_labels_change_numbers, attributes)
+      end
+
+      split_names = treatments_labels_change_numbers.keys
+      treatments = treatments_labels_change_numbers.values.map { |v| v[:treatment] }
+
+      Hash[split_names.zip(treatments)]
+    end
+
+    #
+    # obtains the treatment for a given feature
+    #
+    # @param key [String/Hash] user id or hash with matching_key/bucketing_key
+    # @param split_name [String/Array] name of the feature that is being validated or array of them
+    # @param attributes [Hash] attributes to pass to the treatment class
+    # @param split_data [Hash] split data, when provided this method doesn't fetch splits_repository for the data
+    # @param store_impressions [Boolean] impressions aren't stored if this flag is false
+    # @param multiple [Hash] internal flag to signal if method is called by get_treatments
+    # @param evaluator [Evaluator] Evaluator class instance, used to cache treatments
+    #
+    # @return [String/Hash] Treatment as String or Hash of treatments in case of array of features
+    def get_treatment(
+        key, split_name, attributes = nil, split_data = nil, store_impressions = true,
+        multiple = false, evaluator = nil
+      )
+      bucketing_key, matching_key = keys_from_key(key)
+      treatment_data = { label: Engine::Models::Label::DEFINITION_NOT_FOUND, treatment: SplitIoClient::Engine::Models::Treatment::CONTROL }
+      evaluator ||= Engine::Parser::Evaluator.new(@segments_repository, @splits_repository)
+
+      if matching_key.nil?
+        @config.logger.warn('matching_key was null for split_name: ' + split_name.to_s)
+        return parsed_treatment(multiple, treatment_data)
+      end
+
+      if split_name.nil?
+        @config.logger.warn('split_name was null for key: ' + key)
+        return parsed_treatment(multiple, treatment_data)
+      end
+
+      start = Time.now
+
+      begin
+        split = multiple ? split_data : @splits_repository.get_split(split_name)
+
+        if split.nil?
+          @config.logger.debug("split_name: #{split_name} does not exist. Returning CONTROL")
+          return parsed_treatment(multiple, treatment_data)
+        else
+          treatment_data =
+            evaluator.call(
+            { bucketing_key: bucketing_key, matching_key: matching_key }, split, attributes
+          )
+        end
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+
+        store_impression(
+          split_name, matching_key, bucketing_key,
+          {
+            treatment: SplitIoClient::Engine::Models::Treatment::CONTROL,
+            label: SplitIoClient::Engine::Models::Label::EXCEPTION
+          },
+          store_impressions, attributes
+        )
+
+        return parsed_treatment(multiple, treatment_data)
+      end
+
+      begin
+        latency = (Time.now - start) * 1000.0
+        # Disable impressions if @config.impressions_queue_size == -1
+        split && store_impression(split_name, matching_key, bucketing_key, treatment_data, store_impressions, attributes)
+
+        # Measure
+        @adapter.metrics.time('sdk.get_treatment', latency)
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+
+        store_impression(
+          split_name, matching_key, bucketing_key,
+          {
+            treatment: SplitIoClient::Engine::Models::Treatment::CONTROL,
+            label: SplitIoClient::Engine::Models::Label::EXCEPTION
+          },
+          store_impressions, attributes
+        )
+
+        return parsed_treatment(multiple, treatment_data)
+      end
+
+      parsed_treatment(multiple, treatment_data)
+    end
+
+    def destroy
+      @config.logger.info('Split client shutdown started...') if @config.debug_enabled
+
+      @config.threads[:impressions_sender].raise(SplitIoClient::ImpressionShutdownException)
+      @config.threads.reject { |k, _| k == :impressions_sender }.each do |name, thread|
+        Thread.kill(thread)
+      end
+
+      @metrics_repository.clear
+      @splits_repository.clear
+      @segments_repository.clear
+      @events_repository.clear
+
+      @config.logger.info('Split client shutdown complete') if @config.debug_enabled
+    end
+
+    def store_impression(split_name, matching_key, bucketing_key, treatment, store_impressions, attributes)
+      time = (Time.now.to_f * 1000.0).to_i
+      route_impression(split_name, matching_key, bucketing_key, time, treatment, attributes) if @config.impression_listener && store_impressions
+
+      return if @config.impressions_queue_size <= 0 || !store_impressions
+
+      @impressions_repository.add(split_name,
+        'keyName' => matching_key,
+        'bucketingKey' => bucketing_key,
+        'treatment' => treatment[:treatment],
+        'label' => @config.labels_enabled ? treatment[:label] : nil,
+        'time' => time,
+        'changeNumber' => treatment[:change_number]
+      )
+    rescue StandardError => error
+      @config.log_found_exception(__method__.to_s, error)
+    end
+
+    def route_impression(split_name, matching_key, bucketing_key, time, treatment, attributes)
+      impression_router.add(
+        split_name: split_name,
+        matching_key: matching_key,
+        bucketing_key: bucketing_key,
+        time: time,
+        treatment: treatment,
+        attributes: attributes
+      )
+    end
+
+    def route_impressions(split_names, matching_key, bucketing_key, time, treatments_labels_change_numbers, attributes)
+      impression_router.add_bulk(
+        split_names: split_names,
+        matching_key: matching_key,
+        bucketing_key: bucketing_key,
+        time: time,
+        treatments_labels_change_numbers: treatments_labels_change_numbers,
+        attributes: attributes
+      )
+    end
+
+    def impression_router
+      @impression_router ||= SplitIoClient::ImpressionRouter.new(@config)
+    end
+
+    def track(key, traffic_type, event_type, value = nil)
+      @events_repository.add(key, traffic_type, event_type, (Time.now.to_f * 1000).to_i, value)
+    end
+
+    def keys_from_key(key)
+      case key.class.to_s
+      when 'Hash'
+        key.values_at(:bucketing_key, :matching_key).map { |k| k.nil? ? nil : k.to_s }
+      else
+        [nil, key].map { |k| k.nil? ? nil : k.to_s }
+      end
+    end
+
+    def parsed_treatment(multiple, treatment_data)
+      if multiple
+        {
+          treatment: treatment_data[:treatment],
+          label: treatment_data[:label],
+          change_number: treatment_data[:change_number]
+        }
+      else
+        treatment_data[:treatment]
+      end
+    end
+  end
+end