splitclient-rb 6.3.0 → 8.11.0

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

@@ -1,23 +1,32 @@
 # frozen_string_literal: true
 
-require 'net/http/persistent'
-
 module SplitIoClient
   module Api
     class Client
-      RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
+      def initialize(config)
+        @config = config
+
+        check_faraday_compatibility
+      end
 
-      def get_api(url, api_key, params = {})
+      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] = SplitIoClient.configuration.read_timeout
-          req.options[:open_timeout] = SplitIoClient.configuration.connection_timeout
+          req.options[:timeout] = @config.read_timeout
+          req.options[:open_timeout] = @config.connection_timeout
 
-          SplitLogger.log_if_debug("GET #{url} proxy: #{api_client.proxy}")
+          @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
-        SplitIoClient.configuration.logger.warn("#{e}\nURL:#{url}\nparams:#{params}")
+        @config.logger.warn("#{e}\nURL:#{url}\nparams:#{params}")
         raise e, 'Split SDK failed to connect to backend to retrieve information', e.backtrace
       end
 
@@ -27,65 +36,51 @@ module SplitIoClient
                         .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] = SplitIoClient.configuration.read_timeout
-          req.options[:open_timeout] = SplitIoClient.configuration.connection_timeout
+          req.options[:timeout] = @config.read_timeout
+          req.options[:open_timeout] = @config.connection_timeout
 
-          SplitLogger.log_if_transport("POST #{url} #{req.body}")
-          SplitLogger.log_if_debug("POST #{url}")
+          @config.split_logger.log_if_transport("POST #{url} #{req.body}")
+          @config.split_logger.log_if_debug("POST #{url}")
         end
       rescue StandardError => e
-        SplitIoClient.configuration.logger.warn("#{e}\nURL:#{url}\ndata:#{data}\nparams:#{params}")
+        @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
-        if needs_patched_net_http_persistent_adapter?
-          require 'splitclient-rb/engine/api/faraday_adapter/patched_net_http_persistent'
-
-          Faraday::Adapter.register_middleware(
-            net_http_persistent: SplitIoClient::FaradayAdapter::PatchedNetHttpPersistent
-          )
-        end
-
         @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 needs_patched_net_http_persistent_adapter?
-        new_net_http_persistent? && incompatible_faraday_version?
-      end
-
-      def incompatible_faraday_version?
-        version = Faraday::VERSION.split('.')[0..1]
-        version[0].to_i == 0 && version[1].to_i < 13
-      end
-
-      def new_net_http_persistent?
-        Net::HTTP::Persistent::VERSION.split('.').first.to_i >= 3
-      end
-
       def common_headers(api_key)
         {
           'Authorization' => "Bearer #{api_key}",
-          'SplitSDKVersion' => "#{SplitIoClient.configuration.language}-#{SplitIoClient.configuration.version}",
-          'SplitSDKMachineName' => SplitIoClient.configuration.machine_name,
-          'SplitSDKMachineIP' => SplitIoClient.configuration.machine_ip,
-          'Referer' => referer
+          'SplitSDKVersion' => "#{@config.language}-#{@config.version}",
         }
       end
 
-      def referer
-        result = "#{SplitIoClient.configuration.language}-#{SplitIoClient.configuration.version}"
+      def check_faraday_compatibility
+        version = Faraday::VERSION.split('.')[0]
 
-        result = "#{result}::#{SplitIoClient::SplitConfig.machine_hostname}" unless SplitIoClient::SplitConfig.machine_hostname == 'localhost'
-
-        result
+        require 'faraday/net_http_persistent' if version.to_i >= 2
+      rescue StandardError => e
+        @config.logger.warn(e)
       end
     end
   end

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

@@ -3,30 +3,37 @@
 module SplitIoClient
   module Api
     class Events < Client
-      def initialize(api_key)
+      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?
-          SplitLogger.log_if_debug('No events to report')
+          @config.split_logger.log_if_debug('No events to report')
           return
         end
 
-        events.each_slice(SplitIoClient.configuration.events_queue_size) do |events_slice|
+        start = Time.now
+
+        events.each_slice(@config.events_queue_size) do |events_slice|
           response = post_api(
-            "#{SplitIoClient.configuration.events_uri}/events/bulk",
+            "#{@config.events_uri}/events/bulk",
             @api_key,
-            events_slice.map { |event| formatted_event(event[:e]) },
-            'SplitSDKMachineIP' => events_slice[0][:m][:i],
-            'SplitSDKMachineName' => events_slice[0][:m][:n],
-            'SplitSDKVersion' => events_slice[0][:m][:s]
+            events_slice.map { |event| formatted_event(event[:e]) }
           )
 
           if response.success?
-            SplitLogger.log_if_debug("Events reported: #{events_slice.size}")
+            @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
-            SplitLogger.log_error("Unexpected status code while posting events: #{response.status}." \
+            @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
@@ -41,7 +48,8 @@ module SplitIoClient
           trafficTypeName: event[:trafficTypeName],
           eventTypeId: event[:eventTypeId],
           value: event[:value].to_f,
-          timestamp: event[:timestamp].to_i
+          timestamp: event[:timestamp].to_i,
+          properties: event[:properties]
         }
       end
     end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'faraday'
+require 'stringio'
 
 module SplitIoClient
   module FaradayMiddleware

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

@@ -3,26 +3,59 @@
 module SplitIoClient
   module Api
     class Impressions < Client
-      def initialize(api_key)
+      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?
-          SplitLogger.log_if_debug('No impressions to report')
+          @config.split_logger.log_if_debug('No impressions to report')
           return
         end
 
-        impressions_by_ip(impressions).each do |ip, impressions_ip|
-          response = post_api("#{SplitIoClient.configuration.events_uri}/testImpressions/bulk", @api_key, impressions_ip, 'SplitSDKMachineIP' => ip)
+        start = Time.now
 
-          if response.success?
-            SplitLogger.log_if_debug("Impressions reported: #{total_impressions(impressions)}")
-          else
-            SplitLogger.log_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
+        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
 
@@ -30,14 +63,16 @@ module SplitIoClient
         return 0 if impressions.nil?
 
         impressions.reduce(0) do |impressions_count, impression|
-          impressions_count += impression[:keyImpressions].length
+          impressions_count += impression[:i].length
         end
       end
 
       private
 
-      def impressions_by_ip(impressions)
-        impressions.group_by { |impression| impression[:ip] }
+      def impressions_headers
+        {
+          'SplitSDKImpressionsMode' => @config.impressions_mode.to_s
+        }
       end
     end
   end

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

@@ -4,26 +4,24 @@ module SplitIoClient
   module Api
     # Retrieves segment changes from the Split Backend
     class Segments < Client
-      METRICS_PREFIX = 'segmentChangeFetcher'
-
-      def initialize(api_key, metrics, segments_repository)
-        @metrics = metrics
+      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 store_segments_by_names(names)
-        start = Time.now
-
+      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)
+            segment = fetch_segment_changes(name, since, fetch_options)
             @segments_repository.add_to_segment(segment)
 
-            SplitLogger.log_if_debug("Segment #{name} fetched before: #{since}, \
+            @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
@@ -31,38 +29,47 @@ module SplitIoClient
             since = @segments_repository.get_change_number(name)
           end
         end
-
-        latency = (Time.now - start) * 1000.0
-        @metrics.time(METRICS_PREFIX + '.time', latency)
       end
 
       private
 
-      def fetch_segment_changes(name, since)
-        response = get_api("#{SplitIoClient.configuration.base_uri}/segmentChanges/#{name}", @api_key, since: since)
+      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])
-          @metrics.count(METRICS_PREFIX + '.status.' + response.status.to_s, 1)
 
-          SplitLogger.log_if_debug("\'#{segment[:name]}\' segment retrieved.")
+          @config.split_logger.log_if_debug("\'#{segment[:name]}\' segment retrieved.")
           unless segment[:added].empty?
-            SplitLogger.log_if_debug("\'#{segment[:name]}\' #{segment[:added].size} added keys")
+            @config.split_logger.log_if_debug("\'#{segment[:name]}\' #{segment[:added].size} added keys")
           end
           unless segment[:removed].empty?
-            SplitLogger.log_if_debug("\'#{segment[:name]}\' #{segment[:removed].size} removed keys")
+            @config.split_logger.log_if_debug("\'#{segment[:name]}\' #{segment[:removed].size} removed keys")
           end
-          SplitLogger.log_if_transport(segment.to_s)
+          @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
-            SplitIoClient.configuration.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')
-            SplitIoClient.configuration.valid_mode =  false
+          @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
-          SplitLogger.log_error("Unexpected status code while fetching segments: #{response.status}." \
+          @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")
-          @metrics.count(METRICS_PREFIX + '.status.' + response.status.to_s, 1)
+
           raise 'Split SDK failed to connect to backend to fetch segments'
         end
       end

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

@@ -4,60 +4,135 @@ module SplitIoClient
   module Api
     # Retrieves split definitions from the Split Backend
     class Splits < Client
-      METRICS_PREFIX = 'splitChangeFetcher'
 
-      def initialize(api_key, metrics)
+      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
-        @metrics = metrics
+        @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)
+      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
 
-        response = get_api("#{SplitIoClient.configuration.base_uri}/splitChanges", @api_key, since: since)
+        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 = splits_with_segment_names(response.body)
+          result = JSON.parse(response.body, symbolize_names: true)
 
-          @metrics.count(METRICS_PREFIX + '.status.' + response.status.to_s, 1)
-          unless result[:splits].empty?
-            SplitLogger.log_if_debug("#{result[:splits].length} splits retrieved. since=#{since}")
-          end
-          SplitLogger.log_if_transport(result.to_s)
+          return process_result(result, since, since_rbs, start)
+        end
+        @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::SPLIT_SYNC, response.status)
 
-          latency = (Time.now - start) * 1000.0
-          @metrics.time(METRICS_PREFIX + '.time', latency)
+        @config.logger.error("Unexpected status code while fetching feature flags: #{response.status}. " \
+        'Check your API key and base URI')
 
-          result
-        else
-          @metrics.count(METRICS_PREFIX + '.status.' + response.status.to_s, 1)
-          SplitLogger.log_error("Unexpected status code while fetching splits: #{response.status}. " \
-          'Check your API key and base URI')
-          raise 'Split SDK failed to connect to backend to fetch split definitions'
-        end
+        raise 'Split SDK failed to connect to backend to fetch feature flags definitions'
+      end
+
+      def clear_storage
+        @clear_storage
       end
 
       private
 
-      def splits_with_segment_names(splits_json)
-        parsed_splits = JSON.parse(splits_json, symbolize_names: true)
+      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
 
-        parsed_splits[:segment_names] =
-          parsed_splits[:splits].each_with_object(Set.new) do |split, splits|
-            splits << segment_names(split)
-          end.flatten
+        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}")
 
-        parsed_splits
+        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 segment_names(split)
-        split[:conditions].each_with_object(Set.new) do |condition, names|
-          condition[:matcherGroup][:matchers].each do |matcher|
-            next if matcher[:userDefinedSegmentMatcherData].nil?
+      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
 
-            names << matcher[:userDefinedSegmentMatcherData][:segmentName]
-          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

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