splitclient-rb 1.0.2.wip → 8.11.1.pre.rc1-java

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

@@ -0,0 +1,530 @@
+module SplitIoClient
+  EVENTS_SIZE_THRESHOLD = 32768
+  EVENT_AVERAGE_SIZE = 1024
+  GET_TREATMENT = 'get_treatment'
+  GET_TREATMENTS = 'get_treatments'
+  GET_TREATMENT_WITH_CONFIG = 'get_treatment_with_config'
+  GET_TREATMENTS_WITH_CONFIG = 'get_treatments_with_config'
+  GET_TREATMENTS_BY_FLAG_SET = 'get_treatments_by_flag_set'
+  GET_TREATMENTS_BY_FLAG_SETS = 'get_treatments_by_flag_sets'
+  GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = 'get_treatments_with_config_by_flag_set'
+  GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = 'get_treatments_with_config_by_flag_sets'
+  TRACK = 'track'
+
+  class SplitClient
+    #
+    # Creates a new split client instance that connects to split.io API.
+    #
+    # @param sdk_key [String] the SDK key for your split account
+    #
+    # @return [SplitIoClient] split.io client instance
+    def initialize(sdk_key, repositories, status_manager, config, impressions_manager, telemetry_evaluation_producer, evaluator, split_validator, fallback_treatment_calculator, events_manager)
+      @api_key = sdk_key
+      @splits_repository = repositories[:splits]
+      @segments_repository = repositories[:segments]
+      @rule_based_segments_repository = repositories[:rule_based_segments]
+      @impressions_repository = repositories[:impressions]
+      @events_repository = repositories[:events]
+      @status_manager = status_manager
+      @destroyed = false
+      @config = config
+      @impressions_manager = impressions_manager
+      @telemetry_evaluation_producer = telemetry_evaluation_producer
+      @split_validator = split_validator
+      @evaluator = evaluator
+      @fallback_treatment_calculator = fallback_treatment_calculator
+      @events_manager = events_manager
+    end
+
+    def get_treatment(
+        key, split_name, attributes = {}, evaluation_options = nil, split_data = nil, store_impressions = nil,
+        multiple = false, evaluator = nil
+      )
+      log_deprecated_warning(GET_TREATMENT, evaluator, 'evaluator')
+    
+      result = treatment(key, split_name, attributes, split_data, store_impressions, GET_TREATMENT, multiple, evaluation_options)
+      return result.tap { |t| t.delete(:config) } if multiple
+      result[:treatment]
+    end
+
+    def get_treatment_with_config(
+        key, split_name, attributes = {}, evaluation_options = nil, split_data = nil, store_impressions = nil,
+        multiple = false, evaluator = nil
+      )
+      log_deprecated_warning(GET_TREATMENT, evaluator, 'evaluator')
+      result = treatment(key, split_name, attributes, split_data, store_impressions, GET_TREATMENT_WITH_CONFIG, multiple, evaluation_options)
+
+      { :config => result[:config], :treatment => result[:treatment] }
+    end
+
+    def get_treatments(key, split_names, attributes = {}, evaluation_options = nil)
+      treatments = treatments(key, split_names, attributes, evaluation_options)
+
+      return treatments if treatments.nil?
+      keys = treatments.keys
+      treats = treatments.map { |_,t| t[:treatment]  }
+      Hash[keys.zip(treats)]
+    end
+
+    def get_treatments_with_config(key, split_names, attributes = {}, evaluation_options = nil)
+      results = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_WITH_CONFIG)
+
+      results.map{|key, value|
+        [key, { treatment: value[:treatment], config: value[:config] }]
+      }.to_h
+    end
+
+    def get_treatments_by_flag_set(key, flag_set, attributes = {}, evaluation_options = nil)
+      valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_BY_FLAG_SET, [flag_set])
+      split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
+      treatments = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_BY_FLAG_SET)
+      return treatments if treatments.nil?
+      keys = treatments.keys
+      treats = treatments.map { |_,t| t[:treatment]  }
+      Hash[keys.zip(treats)]
+    end
+
+    def get_treatments_by_flag_sets(key, flag_sets, attributes = {}, evaluation_options = nil)
+      valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_BY_FLAG_SETS, flag_sets)
+      split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
+      treatments = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_BY_FLAG_SETS)
+      return treatments if treatments.nil?
+      keys = treatments.keys
+      treats = treatments.map { |_,t| t[:treatment]  }
+      Hash[keys.zip(treats)]
+    end
+
+    def get_treatments_with_config_by_flag_set(key, flag_set, attributes = {}, evaluation_options = nil)
+      valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, [flag_set])
+      split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
+      results = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET)
+
+      results.map{|key, value|
+        [key, { treatment: value[:treatment], config: value[:config] }]
+      }.to_h
+    end
+
+    def get_treatments_with_config_by_flag_sets(key, flag_sets, attributes = {}, evaluation_options = nil)
+      valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, flag_sets)
+      split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
+      results = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS)
+
+      results.map{|key, value|
+        [key, { treatment: value[:treatment], config: value[:config] }]
+      }.to_h
+    end
+
+    def destroy
+      @config.logger.info('Split client shutdown started...') if @config.debug_enabled
+      if !@config.cache_adapter.is_a?(SplitIoClient::Cache::Adapters::RedisAdapter) && @config.impressions_mode != :none &&
+          (!@impressions_repository.empty? || !@events_repository.empty?)
+        @config.logger.debug("Impressions and/or Events cache is not empty") if @config.debug_enabled
+        # Adding small delay to ensure sender threads are fully running
+        sleep(0.1)
+        if !@config.threads.key?(:impressions_sender) || !@config.threads.key?(:events_sender)
+          @config.logger.debug("Periodic data recording thread has not started yet, waiting for service startup.") if @config.debug_enabled
+          @config.threads[:start_sdk].join(5) if @config.threads.key?(:start_sdk)
+        end
+      end
+      @config.threads.select { |name, thread| name.to_s.end_with? 'sender' }.values.each do |thread|
+        thread.raise(SplitIoClient::SDKShutdownException)
+        thread.join
+      end
+
+      @config.threads.values.each { |thread| Thread.kill(thread) }
+
+      @splits_repository.clear
+      @segments_repository.clear
+      @rule_based_segments_repository.clear
+
+      SplitIoClient.load_factory_registry
+      SplitIoClient.split_factory_registry.remove(@api_key)
+
+      @config.logger.info('Split client shutdown complete') if @config.debug_enabled
+      @config.valid_mode = false
+      @destroyed = true
+    end
+
+    def track(key, traffic_type_name, event_type, value = nil, properties = nil)
+      return false unless valid_client && @config.split_validator.valid_track_parameters(key, traffic_type_name, event_type, value, properties)
+
+      start = Time.now
+      properties_size = EVENT_AVERAGE_SIZE
+
+      if !properties.nil?
+        properties, size = validate_properties(properties)
+        properties_size += size
+        return false unless check_properties_size(properties_size)
+      end
+
+      if ready? && !@config.localhost_mode && !@splits_repository.traffic_type_exists(traffic_type_name)
+        @config.logger.warn("track: Traffic Type #{traffic_type_name} " \
+          "does not have any corresponding feature flags in this environment, make sure you're tracking " \
+          'your events to a valid traffic type defined in the Split user interface')
+      end
+
+      @events_repository.add(key.to_s, traffic_type_name.downcase, event_type.to_s, (Time.now.to_f * 1000).to_i, value, properties, properties_size)
+      record_latency(TRACK, start)
+      true
+    rescue StandardError => e
+      @config.log_found_exception(__method__.to_s, e)
+      record_exception(TRACK)
+
+      false
+    end
+
+    def block_until_ready(time = nil)
+      @status_manager.wait_until_ready(time) if @status_manager
+    end
+
+    def register(sdk_event, handler)
+      @events_manager.register(sdk_event, handler)
+    end
+
+    def unregister(sdk_event, handler)
+      @events_manager.unregister(sdk_event)
+    end
+
+    private
+
+    def check_properties_size(properties_size, msg = "Event not queued")
+      if (properties_size > EVENTS_SIZE_THRESHOLD)
+        @config.logger.error("The maximum size allowed for the properties is #{EVENTS_SIZE_THRESHOLD}. Current is #{properties_size}. #{msg}")
+        return false
+      end
+      return true
+    end
+
+    def keys_from_key(key)
+      case key
+      when Hash
+        key.values_at(:bucketing_key, :matching_key).map { |k| k.nil? ? nil : k }
+      else
+        [nil, key].map { |k| k.nil? ? nil : k }
+      end
+    end
+
+    def parsed_treatment(treatment_data, multiple = false)
+      if multiple
+      {
+        treatment: treatment_data[:treatment],
+        label: treatment_data[:label],
+        change_number: treatment_data[:change_number],
+        config: treatment_data[:config]
+      }
+      else
+      {
+        treatment: treatment_data[:treatment],
+        config: treatment_data[:config],
+      }
+      end
+    end
+
+    def sanitize_split_names(calling_method, split_names)
+      return nil if !split_names.is_a?(Array)
+
+      split_names.compact.uniq.select do |split_name|
+        if split_name.nil?
+          false
+        elsif (split_name.is_a?(String) || split_name.is_a?(Symbol)) && !split_name.empty?
+          true
+        elsif split_name.is_a?(String) && split_name.empty?
+          @config.logger.warn("#{calling_method}: you passed an empty feature_flag_name, flag name must be a non-empty String or a Symbol")
+          false
+        else
+          @config.logger.warn("#{calling_method}: you passed an invalid feature_flag_name, flag name must be a non-empty String or a Symbol")
+          false
+        end
+      end
+    end
+
+    def validate_properties(properties, method = 'Event')
+      properties_count = 0
+      size = 0
+
+      fixed_properties = properties.each_with_object({}) { |(key, value), result|
+
+        if(key.is_a?(String) || key.is_a?(Symbol))
+          properties_count += 1
+          size += variable_size(key)
+          if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.nil?
+            result[key] = value
+            size += variable_size(value)
+          else
+            @config.logger.warn("Property #{key} is of invalid type. Setting value to nil")
+            result[key] = nil
+          end
+        end
+      }
+
+      @config.logger.warn("#{method} has more than 300 properties. Some of them will be trimmed when processed") if properties_count > 300
+
+      return fixed_properties, size
+    end
+
+    def validate_evaluation_options(evaluation_options)
+      if !evaluation_options.is_a?(SplitIoClient::Engine::Models::EvaluationOptions)
+        @config.logger.warn("Option #{evaluation_options} should be a EvaluationOptions type. Setting value to nil")
+        return nil, 0
+      end
+      evaluation_options.properties = evaluation_options.properties.transform_keys(&:to_sym)
+      evaluation_options.properties, size = validate_properties(evaluation_options.properties, 'Treatment')
+      return evaluation_options, size
+    end
+
+    def valid_client
+      if @destroyed
+        @config.logger.error('Client has already been destroyed - no calls possible')
+        return false
+      end
+      @config.valid_mode
+    end
+
+    def treatments(key, feature_flag_names, attributes = {}, evaluation_options = nil, calling_method = 'get_treatments')
+      sanitized_feature_flag_names = sanitize_split_names(calling_method, feature_flag_names)
+
+      if sanitized_feature_flag_names.nil?
+        @config.logger.error("#{calling_method}: feature_flag_names must be a non-empty Array")
+        return nil
+      end
+
+      if sanitized_feature_flag_names.empty?
+        @config.logger.error("#{calling_method}: feature_flag_names must be a non-empty Array")
+        return {}
+      end
+
+      bucketing_key, matching_key = keys_from_key(key)
+      bucketing_key = bucketing_key ? bucketing_key.to_s : nil
+      matching_key = matching_key ? matching_key.to_s : nil
+      attributes = parsed_attributes(attributes)
+
+      if !@config.split_validator.valid_get_treatments_parameters(calling_method, key, sanitized_feature_flag_names, matching_key, bucketing_key, attributes)
+        to_return = Hash.new
+        sanitized_feature_flag_names.each {|name|
+          to_return[name.to_sym] = check_fallback_treatment(name, '')
+        }
+        return to_return
+      end
+
+      if !ready?
+        impressions = []
+        to_return = Hash.new
+        sanitized_feature_flag_names.each {|name|
+          treatment_data = check_fallback_treatment(name, Engine::Models::Label::NOT_READY)
+          to_return[name.to_sym] = treatment_data
+
+          impressions << { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, name.to_sym, 
+                                                               get_treatment_without_config(treatment_data), false, { attributes: attributes, time: nil },
+                                                               evaluation_options), :disabled => false }
+        }
+        @impressions_manager.track(impressions)
+        return to_return
+      end
+
+      valid_feature_flag_names = []
+      sanitized_feature_flag_names.each { |feature_flag_name|
+        valid_feature_flag_names << feature_flag_name unless feature_flag_name.nil?
+      }
+      start = Time.now
+
+      feature_flags = @splits_repository.splits(valid_feature_flag_names)
+      treatments = Hash.new
+      invalid_treatments = Hash.new
+      feature_flags.each do |key, feature_flag|
+        if feature_flag.nil?
+          @config.logger.warn("#{calling_method}: you passed #{key} that " \
+            'does not exist in this environment, please double check what feature flags exist in the Split user interface')
+            invalid_treatments[key] = check_fallback_treatment(key, Engine::Models::Label::NOT_FOUND)
+          next
+        end
+        treatments_labels_change_numbers, impressions = evaluate_treatment(feature_flag, key, bucketing_key, matching_key, attributes, calling_method, false, evaluation_options)
+        treatments[key] =
+        {
+          treatment: treatments_labels_change_numbers[:treatment],
+          config: treatments_labels_change_numbers[:config]
+        }
+        @impressions_manager.track(impressions) unless impressions.empty?
+      end
+      record_latency(calling_method, start)
+
+      treatments.merge(invalid_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
+    # @return [String/Hash] Treatment as String or Hash of treatments in case of array of features
+    def treatment(key, feature_flag_name, attributes = {}, split_data = nil, store_impressions = nil,
+                   calling_method = 'get_treatment', multiple = false, evaluation_options = nil)
+
+      log_deprecated_warning(calling_method, split_data, 'split_data')
+      log_deprecated_warning(calling_method, store_impressions, 'store_impressions')
+        
+      impressions = []
+      bucketing_key, matching_key = keys_from_key(key)
+
+      attributes = parsed_attributes(attributes)
+
+      return parsed_treatment(check_fallback_treatment(feature_flag_name, ""), multiple) unless valid_client && @config.split_validator.valid_get_treatment_parameters(calling_method, key, feature_flag_name, matching_key, bucketing_key, attributes)
+
+      bucketing_key = bucketing_key ? bucketing_key.to_s : nil
+      matching_key = matching_key.to_s
+      sanitized_feature_flag_name = feature_flag_name.to_s.strip
+
+      if feature_flag_name.to_s != sanitized_feature_flag_name
+        @config.logger.warn("#{calling_method}: feature_flag_name #{feature_flag_name} has extra whitespace, trimming")
+        feature_flag_name = sanitized_feature_flag_name
+      end
+
+      feature_flag = @splits_repository.get_split(feature_flag_name)
+      treatments, impressions_decorator = evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple, evaluation_options)
+
+      @impressions_manager.track(impressions_decorator) unless impressions_decorator.nil?
+      treatments
+    end
+
+    def log_deprecated_warning(calling_method, parameter, parameter_name)
+        @config.logger.warn("#{calling_method}: detected #{parameter_name} parameter used, this parameter is deprecated and its value is ignored.") unless parameter.nil?
+    end
+
+    def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple = false, evaluation_options = nil)
+      impressions_decorator = []
+      begin
+        start = Time.now
+        if feature_flag.nil? && ready?
+          @config.logger.warn("#{calling_method}: you passed #{feature_flag_name} that " \
+            'does not exist in this environment, please double check what feature flags exist in the Split user interface')
+          return check_fallback_treatment(feature_flag_name, Engine::Models::Label::NOT_FOUND), nil
+        end
+
+        if !feature_flag.nil? && ready?
+          treatment_data = @evaluator.evaluate_feature_flag(
+            { bucketing_key: bucketing_key, matching_key: matching_key }, feature_flag, attributes
+          )
+          impressions_disabled = feature_flag[:impressionsDisabled]
+        else
+          @config.logger.error("#{calling_method}: the SDK is not ready, results may be incorrect for feature flag #{feature_flag_name}. Make sure to wait for SDK readiness before using this method.")
+          treatment_data = check_fallback_treatment(feature_flag_name, Engine::Models::Label::NOT_READY)
+          impressions_disabled = false
+        end
+
+        evaluation_options, size = validate_evaluation_options(evaluation_options) unless evaluation_options.nil?
+        evaluation_options.properties = nil unless evaluation_options.nil? or check_properties_size((EVENT_AVERAGE_SIZE + size), "Properties are ignored")
+
+        record_latency(calling_method, start)
+        impression_decorator = { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, treatment_data, impressions_disabled, { attributes: attributes, time: nil }, evaluation_options), :disabled => impressions_disabled }
+        impressions_decorator << impression_decorator unless impression_decorator.nil?
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+        record_exception(calling_method)
+        treatment_data = check_fallback_treatment(feature_flag_name, Engine::Models::Label::EXCEPTION)
+        impression_decorator = { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, get_treatment_without_config(treatment_data), false, { attributes: attributes, time: nil }, evaluation_options), :disabled => false }
+
+        impressions_decorator << impression_decorator unless impression_decorator.nil?
+
+        return parsed_treatment(treatment_data, multiple), impressions_decorator
+      end
+      return parsed_treatment(treatment_data, multiple), impressions_decorator
+    end
+
+    def variable_size(value)
+      value.is_a?(String) ? value.length : 0
+    end
+
+    def ready?
+      return @status_manager.ready? if @status_manager
+      true
+    end
+
+    def parsed_attributes(attributes)
+      return attributes || attributes.to_h
+    end
+
+    def record_latency(method, start)
+      bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+
+      case method
+      when GET_TREATMENT
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENT, bucket)
+      when GET_TREATMENTS
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS, bucket)
+      when GET_TREATMENT_WITH_CONFIG
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG, bucket)
+      when GET_TREATMENTS_WITH_CONFIG
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG, bucket)
+      when GET_TREATMENTS_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET, bucket)
+      when GET_TREATMENTS_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS, bucket)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET, bucket)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, bucket)
+      when TRACK
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TRACK, bucket)
+      end
+    end
+
+    def record_exception(method)
+      case method
+      when GET_TREATMENT
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENT)
+      when GET_TREATMENTS
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS)
+      when GET_TREATMENT_WITH_CONFIG
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG)
+      when GET_TREATMENTS_WITH_CONFIG
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG)
+      when GET_TREATMENTS_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET)
+      when GET_TREATMENTS_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS)
+      when TRACK
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TRACK)
+      end
+    end
+
+    def check_fallback_treatment(feature_name, label)
+      return  { 
+        label: (label != '')? label : nil,  
+        treatment: Engine::Models::Treatment::CONTROL, 
+        config: nil,
+        change_number: nil
+      } unless feature_name.is_a?(Symbol) || feature_name.is_a?(String)
+
+      fallback_treatment = @fallback_treatment_calculator.resolve(feature_name.to_sym, label)
+
+      { 
+        label: (label != '')? fallback_treatment.label : nil, 
+        treatment: fallback_treatment.treatment, 
+        config: get_fallback_config(fallback_treatment),
+        change_number: nil
+      }        
+    end
+
+    def get_treatment_without_config(treatment)
+      { 
+        label: treatment[:label], 
+        treatment: treatment[:treatment], 
+      }        
+    end
+
+    def get_fallback_config(fallback_treatment)
+      if fallback_treatment.config != nil
+          return fallback_treatment.config
+      end
+
+      return nil
+    end
+
+  end
+end

data/lib/splitclient-rb/constants.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class SplitIoClient::Constants
+  EXPIRATION_RATE = 600
+  CONTROL_PRI = 'control_pri'
+  CONTROL_SEC = 'control_sec'
+  OCCUPANCY_CHANNEL_PREFIX = '[?occupancy=metrics.publishers]'
+  FETCH_BACK_OFF_BASE_RETRIES = 1
+  PUSH_CONNECTED = 'PUSH_CONNECTED'
+  PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
+  PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
+  PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'
+  PUSH_SUBSYSTEM_READY = 'PUSH_SUBSYSTEM_READY'
+  PUSH_SUBSYSTEM_OFF = 'PUSH_SUBSYSTEM_OFF'
+  PUSH_FORCED_STOP = 'PUSH_FORCED_STOP'
+end

data/lib/splitclient-rb/engine/api/client.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Api
+    class Client
+      def initialize(config)
+        @config = config
+
+        check_faraday_compatibility
+      end
+
+      def get_api(url, api_key, params = {}, cache_control_headers = false)
+        api_client.options.params_encoder.sort_params = false
+        api_client.get(url, params) do |req|
+          req.headers = common_headers(api_key).merge('Accept-Encoding' => 'gzip')
+          req.headers = req.headers.merge('Cache-Control' => 'no-cache') if cache_control_headers
+
+          req.options[:timeout] = @config.read_timeout
+          req.options[:open_timeout] = @config.connection_timeout
+
+          @config.split_logger.log_if_debug("GET #{url} proxy: #{api_client.proxy}")
+        end
+      
+      rescue Zlib::GzipFile::Error => e
+        @config.logger.warn("Incorrect formatted response exception: #{e}\n")
+        SplitIoClient::Engine::Models::SplitHttpResponse.new(400, '', true)
+
+      rescue StandardError => e
+        @config.logger.warn("#{e}\nURL:#{url}\nparams:#{params}")
+        raise e, 'Split SDK failed to connect to backend to retrieve information', e.backtrace
+      end
+
+      def post_api(url, api_key, data, headers = {}, params = {})
+        api_client.post(url) do |req|
+          req.headers = common_headers(api_key)
+                        .merge('Content-Type' => 'application/json')
+                        .merge(headers)
+
+          machine_ip = @config.machine_ip
+          machine_name = @config.machine_name
+
+          req.headers = req.headers.merge('SplitSDKMachineIP' => machine_ip) unless machine_ip.empty? || machine_ip == 'unknown'
+          req.headers = req.headers.merge('SplitSDKMachineName' => machine_name) unless machine_name.empty? || machine_name == 'unknown'
+
+          req.body = data.to_json
+
+          req.options[:timeout] = @config.read_timeout
+          req.options[:open_timeout] = @config.connection_timeout
+
+          @config.split_logger.log_if_transport("POST #{url} #{req.body}")
+          @config.split_logger.log_if_debug("POST #{url}")
+        end
+      rescue StandardError => e
+        @config.logger.warn("#{e}\nURL:#{url}\ndata:#{data}\nparams:#{params}")
+        raise e, 'Split SDK failed to connect to backend to post information', e.backtrace
+      end
+
+      def sdk_url_overriden?
+        @config.sdk_url_overriden?
+      end
+      private
+
+      def api_client
+        @api_client ||= Faraday.new do |builder|
+          builder.use SplitIoClient::FaradayMiddleware::Gzip
+          builder.adapter :net_http_persistent
+          builder.options.params_encoder = Faraday::FlatParamsEncoder
+        end
+      end
+
+      def common_headers(api_key)
+        {
+          'Authorization' => "Bearer #{api_key}",
+          'SplitSDKVersion' => "#{@config.language}-#{@config.version}",
+        }
+      end
+
+      def check_faraday_compatibility
+        version = Faraday::VERSION.split('.')[0]
+
+        require 'faraday/net_http_persistent' if version.to_i >= 2
+      rescue StandardError => e
+        @config.logger.warn(e)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/api/events.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Api
+    class Events < Client
+      def initialize(api_key, config, telemetry_runtime_producer)
+        super(config)
+        @api_key = api_key
+        @telemetry_runtime_producer = telemetry_runtime_producer
+      end
+
+      def post(events)
+        if events.empty?
+          @config.split_logger.log_if_debug('No events to report')
+          return
+        end
+
+        start = Time.now
+
+        events.each_slice(@config.events_queue_size) do |events_slice|
+          response = post_api(
+            "#{@config.events_uri}/events/bulk",
+            @api_key,
+            events_slice.map { |event| formatted_event(event[:e]) }
+          )
+
+          if response.success?
+            @config.split_logger.log_if_debug("Events reported: #{events_slice.size}")
+
+            bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+            @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::EVENT_SYNC, bucket)
+            @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::EVENT_SYNC, (Time.now.to_f * 1000.0).to_i)
+          else
+            @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::EVENT_SYNC, response.status)
+
+            @config.logger.error("Unexpected status code while posting events: #{response.status}." \
+            ' - Check your API key and base URI')
+            raise 'Split SDK failed to connect to backend to post events'
+          end
+        end
+      end
+
+      private
+
+      def formatted_event(event)
+        {
+          key: event[:key],
+          trafficTypeName: event[:trafficTypeName],
+          eventTypeId: event[:eventTypeId],
+          value: event[:value].to_f,
+          timestamp: event[:timestamp].to_i,
+          properties: event[:properties]
+        }
+      end
+    end
+  end
+end