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

data/lib/splitclient-rb/engine/api/faraday_middleware/gzip.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'stringio'
+
+module SplitIoClient
+  module FaradayMiddleware
+    class Gzip < Faraday::Middleware
+      ACCEPT_ENCODING = 'Accept-Encoding'
+      CONTENT_ENCODING = 'Content-Encoding'
+      CONTENT_LENGTH = 'Content-Length'
+      SUPPORTED_ENCODINGS = 'gzip,deflate'
+      RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
+
+      def call(env)
+        env[:request_headers][ACCEPT_ENCODING] ||= SUPPORTED_ENCODINGS
+        @app.call(env).on_complete do |response_env|
+          case response_env[:response_headers][CONTENT_ENCODING]
+          when 'gzip'
+            reset_body(response_env, &method(:uncompress_gzip))
+          when 'deflate'
+            reset_body(response_env, &method(:inflate))
+          end
+        end
+      end
+
+      def reset_body(env)
+        env[:body] = yield(env[:body])
+        env[:response_headers].delete(CONTENT_ENCODING)
+        env[:response_headers][CONTENT_LENGTH] = env[:body].length
+      end
+
+      def uncompress_gzip(body)
+        io = StringIO.new(body)
+        gzip_reader = if RUBY_ENCODING
+                        Zlib::GzipReader.new(io, encoding: 'ASCII-8BIT')
+                      else
+                        Zlib::GzipReader.new(io)
+                      end
+        gzip_reader.read
+      end
+
+      def inflate(body)
+        # Inflate as a DEFLATE (RFC 1950+RFC 1951) stream
+        Zlib::Inflate.inflate(body)
+      rescue Zlib::DataError
+        # Fall back to inflating as a "raw" deflate stream which
+        # Microsoft servers return
+        inflate = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+        begin
+          inflate.inflate(body)
+        ensure
+          inflate.close
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Api
+    class Impressions < Client
+      def initialize(api_key, config, telemetry_runtime_producer)
+        super(config)
+        @api_key = api_key
+        @telemetry_runtime_producer = telemetry_runtime_producer
+      end
+
+      def post(impressions)
+        if impressions.empty?
+          @config.split_logger.log_if_debug('No impressions to report')
+          return
+        end
+
+        start = Time.now
+
+        response = post_api("#{@config.events_uri}/testImpressions/bulk", @api_key, impressions, impressions_headers)
+
+        if response.success?
+          @config.split_logger.log_if_debug("Impressions reported: #{total_impressions(impressions)}")
+          
+          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::IMPRESSIONS_SYNC, bucket)
+          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::IMPRESSIONS_SYNC, (Time.now.to_f * 1000.0).to_i)
+        else
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::IMPRESSIONS_SYNC, response.status)
+
+          @config.logger.error("Unexpected status code while posting impressions: #{response.status}." \
+          ' - Check your API key and base URI')
+          raise 'Split SDK failed to connect to backend to post impressions'
+        end
+      end
+
+      def post_count(impressions_count)
+        if impressions_count.nil? || impressions_count[:pf].empty?
+          @config.split_logger.log_if_debug('No impressions count to send')
+          return
+        end
+
+        start = Time.now
+
+        response = post_api("#{@config.events_uri}/testImpressions/count", @api_key, impressions_count)
+
+        if response.success?
+          @config.split_logger.log_if_debug("Impressions count sent: #{impressions_count[:pf].length}")
+
+          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::IMPRESSION_COUNT_SYNC, bucket)
+          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::IMPRESSION_COUNT_SYNC, (Time.now.to_f * 1000.0).to_i)
+        else
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::IMPRESSION_COUNT_SYNC, response.status)
+
+          @config.logger.error("Unexpected status code while posting impressions count: #{response.status}." \
+          ' - Check your API key and base URI')
+          raise 'Split SDK failed to connect to backend to post impressions'
+        end
+      end
+
+      def total_impressions(impressions)
+        return 0 if impressions.nil?
+
+        impressions.reduce(0) do |impressions_count, impression|
+          impressions_count += impression[:i].length
+        end
+      end
+
+      private
+
+      def impressions_headers
+        {
+          'SplitSDKImpressionsMode' => @config.impressions_mode.to_s
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Api
+    # Retrieves segment changes from the Split Backend
+    class Segments < Client
+      def initialize(api_key, segments_repository, config, telemetry_runtime_producer)
+        super(config)
+        @api_key = api_key
+        @segments_repository = segments_repository
+        @telemetry_runtime_producer = telemetry_runtime_producer
+      end
+
+      def fetch_segments_by_names(names, fetch_options = { cache_control_headers: false, till: nil })
+        return if names.nil? || names.empty?
+
+        names.each do |name|
+          since = @segments_repository.get_change_number(name)
+
+          loop do
+            segment = fetch_segment_changes(name, since, fetch_options)
+            @segments_repository.add_to_segment(segment)
+
+            @config.split_logger.log_if_debug("Segment #{name} fetched before: #{since}, \
+              till: #{@segments_repository.get_change_number(name)}")
+
+            break if since.to_i >= @segments_repository.get_change_number(name).to_i
+
+            since = @segments_repository.get_change_number(name)
+          end
+        end
+      end
+
+      private
+
+      def fetch_segment_changes(name, since, fetch_options = { cache_control_headers: false, till: nil })
+        start = Time.now
+
+        params = { since: since }
+        params[:till] = fetch_options[:till] unless fetch_options[:till].nil?
+        response = get_api("#{@config.base_uri}/segmentChanges/#{name}", @api_key, params, fetch_options[:cache_control_headers])
+
+        if response.success?
+          segment = JSON.parse(response.body, symbolize_names: true)
+          @segments_repository.set_change_number(name, segment[:till])
+
+          @config.split_logger.log_if_debug("\'#{segment[:name]}\' segment retrieved.")
+          unless segment[:added].empty?
+            @config.split_logger.log_if_debug("\'#{segment[:name]}\' #{segment[:added].size} added keys")
+          end
+          unless segment[:removed].empty?
+            @config.split_logger.log_if_debug("\'#{segment[:name]}\' #{segment[:removed].size} removed keys")
+          end
+          @config.split_logger.log_if_transport("Segment changes response: #{segment.to_s}")
+
+          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::SEGMENT_SYNC, bucket)
+          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::SEGMENT_SYNC, (Time.now.to_f * 1000.0).to_i)
+
+          segment
+        elsif response.status == 403
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::SEGMENT_SYNC, response.status)
+
+          @config.logger.error('Factory Instantiation: You passed a browser type api_key, ' \
+            'please grab an api key from the Split console that is of type sdk')
+          @config.valid_mode =  false
+        else
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::SEGMENT_SYNC, response.status)
+
+          @config.logger.error("Unexpected status code while fetching segments: #{response.status}." \
+          "Since #{since} - Check your API key and base URI")
+
+          raise 'Split SDK failed to connect to backend to fetch segments'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Api
+    # Retrieves split definitions from the Split Backend
+    class Splits < Client
+
+      PROXY_CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+      SPEC_1_1 = "1.1"
+
+      def initialize(api_key, config, telemetry_runtime_producer)
+        super(config)
+        @api_key = api_key
+        @telemetry_runtime_producer = telemetry_runtime_producer
+        @flag_sets_filter = @config.flag_sets_filter
+        @spec_version = SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+        @last_proxy_check_timestamp = 0
+        @clear_storage = false
+        @old_spec_since = nil
+      end
+
+      def since(since, since_rbs, fetch_options = { cache_control_headers: false, till: nil, sets: nil})
+        start = Time.now
+        
+        if check_last_proxy_check_timestamp
+            @spec_version = SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+            @config.logger.debug("Switching to new Feature flag spec #{@spec_version} and fetching.") if @config.debug_enabled
+            @old_spec_since = since
+            since = -1
+            since_rbs = -1
+            fetch_options = { cache_control_headers: false, till: nil, sets: nil}
+        end
+
+        if @spec_version == Splits::SPEC_1_1
+          since = @old_spec_since unless @old_spec_since.nil?
+          params = { s: @spec_version, since: since }
+          @old_spec_since = nil
+        else
+          params = { s: @spec_version, since: since, rbSince: since_rbs }
+        end
+
+        params[:sets] = @flag_sets_filter.join(",") unless @flag_sets_filter.empty?
+        params[:till] = fetch_options[:till] unless fetch_options[:till].nil?
+        @config.logger.debug("Fetching from splitChanges with #{params}: ") if @config.debug_enabled
+        response = get_api("#{@config.base_uri}/splitChanges", @api_key, params, fetch_options[:cache_control_headers])
+        if response.status == 414
+          @config.logger.error("Error fetching feature flags; the amount of flag sets provided are too big, causing uri length error.")
+          raise ApiException.new response.body, 414
+        end
+
+        if response.status == 400 and sdk_url_overriden? and @spec_version == SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+            @config.logger.warn("Detected proxy response error, changing spec version from #{@spec_version} to #{Splits::SPEC_1_1} and re-fetching.")
+            @spec_version = Splits::SPEC_1_1
+            @last_proxy_check_timestamp = Time.now
+            return since(since, 0, fetch_options = {cache_control_headers: fetch_options[:cache_control_headers], till: fetch_options[:till],
+                sets: fetch_options[:sets]})          
+        end
+        if response.success?
+          result = JSON.parse(response.body, symbolize_names: true)
+
+          return process_result(result, since, since_rbs, start)
+        end
+        @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::SPLIT_SYNC, response.status)
+
+        @config.logger.error("Unexpected status code while fetching feature flags: #{response.status}. " \
+        'Check your API key and base URI')
+
+        raise 'Split SDK failed to connect to backend to fetch feature flags definitions'
+      end
+
+      def clear_storage
+        @clear_storage
+      end
+
+      private
+
+      def process_result(result, since, since_rbs, start)
+        if @spec_version == Splits::SPEC_1_1
+          result = convert_to_new_spec(result)
+        end
+        
+        result[:rbs][:d] = check_rbs_data(result[:rbs][:d])
+        result = objects_with_segment_names(result)
+        
+        if @spec_version == SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+          @clear_storage = @last_proxy_check_timestamp != 0
+          @last_proxy_check_timestamp = 0
+        end
+
+        unless result[:ff][:d].empty?
+          @config.split_logger.log_if_debug("#{result[:ff][:d].length} feature flags retrieved. since=#{since}")
+        end
+        @config.split_logger.log_if_transport("Feature flag changes response: #{result[:ff].to_s}")
+
+        unless result[:rbs][:d].empty?
+          @config.split_logger.log_if_debug("#{result[:rbs][:d].length} rule based segments retrieved. since=#{since_rbs}")
+        end
+        @config.split_logger.log_if_transport("rule based segments changes response: #{result[:rbs].to_s}")
+
+        bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+        @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::SPLIT_SYNC, bucket)
+        @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::SPLIT_SYNC, (Time.now.to_f * 1000.0).to_i)
+
+        result
+      end
+
+      def check_rbs_data(rbs_data)
+        rbs_data.each do |rb_segment|
+          rb_segment[:excluded] = {:keys => [], :segments => []} if rb_segment[:excluded].nil?
+          rb_segment[:excluded][:keys] = [] if rb_segment[:excluded][:keys].nil?
+          rb_segment[:excluded][:segments] = [] if rb_segment[:excluded][:segments].nil?
+        end
+        rbs_data
+      end
+
+      def objects_with_segment_names(parsed_objects)
+        parsed_objects[:segment_names] = Set.new
+        parsed_objects[:segment_names] =
+          parsed_objects[:ff][:d].each_with_object(Set.new) do |split, splits|
+            splits << Helpers::Util.segment_names_by_object(split, "IN_SEGMENT")
+          end.flatten
+
+        parsed_objects[:rbs][:d].each do |rule_based_segment|
+          parsed_objects[:segment_names].merge Helpers::Util.segment_names_in_rb_segment(rule_based_segment, "IN_SEGMENT")
+        end
+        
+        parsed_objects
+      end
+
+      def check_last_proxy_check_timestamp
+        @spec_version == Splits::SPEC_1_1 and ((Time.now - @last_proxy_check_timestamp) >= Splits::PROXY_CHECK_INTERVAL_SECONDS)
+      end
+
+      def convert_to_new_spec(body)
+        {:ff => {:d => body[:splits], :s => body[:since], :t => body[:till]}, :rbs => {:d => [], :s => -1, :t => -1}}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Api
+    class TelemetryApi < Client
+      def initialize(config, api_key, telemetry_runtime_producer)
+        super(config)
+        @api_key = api_key
+        @telemetry_runtime_producer = telemetry_runtime_producer
+      end
+
+      def record_init(config_init)
+        post_telemetry("#{@config.telemetry_service_url}/metrics/config", config_init, 'init')
+      end
+
+      def record_stats(stats)
+        post_telemetry("#{@config.telemetry_service_url}/metrics/usage", stats, 'stats')
+      end
+
+      def record_unique_keys(uniques)
+        return if uniques[:keys].empty?
+
+        post_telemetry("#{@config.telemetry_service_url}/keys/ss", uniques, 'unique_keys')
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      private
+
+      def post_telemetry(url, obj, method)
+        start = Time.now
+        response = post_api(url, @api_key, obj)
+
+        if response.success?
+          @config.split_logger.log_if_debug("Telemetry post succeeded: record #{method}.")
+          
+          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::TELEMETRY_SYNC, bucket)
+          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::TELEMETRY_SYNC, (Time.now.to_f * 1000.0).to_i)
+        else
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::TELEMETRY_SYNC, response.status)
+          @config.logger.error("Unexpected status code while posting telemetry #{method}: #{response.status}.")
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/auth_api_client.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'jwt'
+require 'cgi'
+
+module SplitIoClient
+  module Engine
+    class AuthApiClient
+      def initialize(config, telemetry_runtime_producer)
+        @config = config
+        @api_client = SplitIoClient::Api::Client.new(@config)
+        @telemetry_runtime_producer = telemetry_runtime_producer
+      end
+
+      def authenticate(api_key)
+        start = Time.now
+        response = @api_client.get_api("#{@config.auth_service_url}?s=#{SplitIoClient::Spec::FeatureFlags::SPEC_VERSION}", api_key)
+
+        return process_success(response, start) if response.success?
+
+        return process_error(response) if response.status >= 400 && response.status < 500
+
+        @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::TOKEN_SYNC, response.status.to_i)
+        if @config.debug_enabled
+          @config.logger.debug("Error connecting to: #{@config.auth_service_url}. Response status: #{response.status}")
+        end
+        { push_enabled: false, retry: true }
+      rescue StandardError => e
+        @config.logger.debug("AuthApiClient error: #{e.inspect}.") if @config.debug_enabled
+        { push_enabled: false, retry: false }
+      end
+
+      private
+
+      def expiration(token_decoded)
+        exp = token_decoded[0]['exp']
+        issued_at = token_decoded[0]['iat']
+
+        exp - issued_at - SplitIoClient::Constants::EXPIRATION_RATE
+      end
+
+      def channels(token_decoded)
+        capability = token_decoded[0]['x-ably-capability']
+        channels_hash = JSON.parse(capability)
+        channels_string = channels_hash.keys.join(',')
+        channels_string = control_channels(channels_string)
+        @config.logger.debug("Channels #{channels_string}") if @config.debug_enabled
+        CGI.escape(channels_string)
+      end
+
+      def decode_token(token)
+        JWT.decode token, nil, false
+      end
+
+      def process_error(response)
+        if @config.debug_enabled
+          @config.logger.debug("Error connecting to: #{@config.auth_service_url}. Response status: #{response.status}")
+        end
+        @telemetry_runtime_producer.record_auth_rejections if response.status == 401
+
+        { push_enabled: false, retry: false }
+      end
+
+      def process_success(response, start)
+        @config.logger.debug("Success connection to: #{@config.auth_service_url}") if @config.debug_enabled
+        record_telemetry(start)
+
+        body_json = JSON.parse(response.body, symbolize_names: true)
+        push_enabled = body_json[:pushEnabled]
+        token = body_json[:token]
+
+        if push_enabled
+          decoded_token = decode_token(token)
+          channels = channels(decoded_token)
+          exp = expiration(decoded_token)
+
+          @telemetry_runtime_producer.record_token_refreshes
+        end
+
+        { push_enabled: push_enabled, token: token, channels: channels, exp: exp, retry: true }
+      end
+
+      def control_channels(channels_string)
+        prefix = SplitIoClient::Constants::OCCUPANCY_CHANNEL_PREFIX
+        control_pri = SplitIoClient::Constants::CONTROL_PRI
+        control_sec = SplitIoClient::Constants::CONTROL_SEC
+        channels_string = channels_string.gsub(control_pri, "#{prefix}#{control_pri}")
+
+        channels_string.gsub(control_sec, "#{prefix}#{control_sec}")
+      end
+
+      def record_telemetry(start)
+        bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+        @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::TOKEN_SYNC, bucket)
+        timestamp = (Time.now.to_f * 1000.0).to_i
+        @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::TOKEN_SYNC, timestamp)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/back_off.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module Engine
+    BACKOFF_MAX_ALLOWED = 1800
+    class BackOff
+      def initialize(back_off_base, attempt = 0, max_allowed = BACKOFF_MAX_ALLOWED)
+        @attempt = attempt
+        @back_off_base = back_off_base
+        @max_allowed = max_allowed
+      end
+
+      def interval
+        interval = 0
+        interval = (@back_off_base * (2**@attempt)) if @attempt.positive?
+        @attempt += 1
+
+        interval >= @max_allowed ? @max_allowed : interval
+      end
+
+      def reset
+        @attempt = 0
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/common/impressions_counter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module SplitIoClient
+  module Engine
+    module Common
+      TIME_INTERVAL_MS = 3600 * 1000
+
+      class ImpressionCounter
+        DEFAULT_AMOUNT = 1
+
+        def initialize
+          @cache = Concurrent::Hash.new
+        end
+
+        def inc(split_name, time_frame)
+          key = make_key(split_name, time_frame)
+
+          current_amount = @cache[key]
+          @cache[key] = current_amount.nil? ? DEFAULT_AMOUNT : (current_amount + DEFAULT_AMOUNT)
+        end
+
+        def pop_all
+          to_return = Concurrent::Hash.new
+
+          @cache.each do |key, value|
+            to_return[key] = value
+          end
+          @cache.clear
+
+          to_return
+        end
+
+        def make_key(split_name, time_frame)
+          "#{split_name}::#{ImpressionCounter.truncate_time_frame(time_frame)}"
+        end
+
+        def self.truncate_time_frame(timestamp_ms)
+          timestamp_ms - (timestamp_ms % TIME_INTERVAL_MS)
+        end
+      end
+    end
+  end
+end