splitclient-rb 6.3.0 → 8.11.0

data/lib/splitclient-rb/telemetry/memory/memory_synchronizer.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemorySynchronizer
+      def initialize(config,
+                     telemtry_consumers,
+                     repositories,
+                     telemetry_api,
+                     flag_sets,
+                     flag_sets_invalid)
+        @config = config
+        @telemetry_init_consumer = telemtry_consumers[:init]
+        @telemetry_runtime_consumer = telemtry_consumers[:runtime]
+        @telemtry_evaluation_consumer = telemtry_consumers[:evaluation]
+        @splits_repository = repositories[:splits]
+        @segments_repository = repositories[:segments]
+        @telemetry_api = telemetry_api
+        @flag_sets = flag_sets
+        @flag_sets_invalid = flag_sets_invalid
+      end
+
+      def synchronize_stats
+        usage = Usage.new(@telemetry_runtime_consumer.last_synchronizations,
+                          @telemtry_evaluation_consumer.pop_latencies,
+                          @telemtry_evaluation_consumer.pop_exceptions,
+                          @telemetry_runtime_consumer.pop_http_errors,
+                          @telemetry_runtime_consumer.pop_http_latencies,
+                          @telemetry_runtime_consumer.pop_token_refreshes,
+                          @telemetry_runtime_consumer.pop_auth_rejections,
+                          @telemetry_runtime_consumer.impressions_stats(Domain::Constants::IMPRESSIONS_QUEUED),
+                          @telemetry_runtime_consumer.impressions_stats(Domain::Constants::IMPRESSIONS_DEDUPE),
+                          @telemetry_runtime_consumer.impressions_stats(Domain::Constants::IMPRESSIONS_DROPPED),
+                          @splits_repository.splits_count,
+                          @segments_repository.segments_count,
+                          @segments_repository.segment_keys_count,
+                          @telemetry_runtime_consumer.session_length,
+                          @telemetry_runtime_consumer.events_stats(Domain::Constants::EVENTS_QUEUED),
+                          @telemetry_runtime_consumer.events_stats(Domain::Constants::EVENTS_DROPPED),
+                          @telemetry_runtime_consumer.pop_streaming_events,
+                          @telemetry_runtime_consumer.pop_tags,
+                          @telemetry_runtime_consumer.pop_updates_from_sse)
+
+        @telemetry_api.record_stats(format_stats(usage))
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def synchronize_config(active_factories = nil, redundant_active_factories = nil, time_until_ready = nil)
+        rates = Rates.new(@config.features_refresh_rate,
+                          @config.segments_refresh_rate,
+                          @config.impressions_refresh_rate,
+                          @config.events_push_rate,
+                          @config.telemetry_refresh_rate)
+
+        url_overrides = UrlOverrides.new(@config.base_uri != SplitConfig.default_base_uri.chomp('/'),
+                                         @config.events_uri != SplitConfig.default_events_uri.chomp('/'),
+                                         @config.auth_service_url != SplitConfig.default_auth_service_url,
+                                         @config.streaming_service_url != SplitConfig.default_streaming_service_url,
+                                         @config.telemetry_service_url != SplitConfig.default_telemetry_service_url)
+
+        active_factories ||= SplitIoClient.split_factory_registry.active_factories
+        redundant_active_factories ||= SplitIoClient.split_factory_registry.redundant_active_factories
+        time_until_ready ||= ((Time.now.to_f - @config.sdk_start_time) * 1000.0).to_i
+
+        init_config = ConfigInit.new(mode,
+                                     'memory',
+                                     active_factories,
+                                     redundant_active_factories,
+                                     @telemetry_runtime_consumer.pop_tags,
+                                     @flag_sets,
+                                     @flag_sets_invalid,
+                                     @config.streaming_enabled,
+                                     rates,
+                                     url_overrides,
+                                     @config.impressions_queue_size,
+                                     @config.events_queue_size,
+                                     impressions_mode,
+                                     !@config.impression_listener.nil?,
+                                     http_proxy_detected?,
+                                     time_until_ready,
+                                     @telemetry_init_consumer.bur_timeouts,
+                                     @telemetry_init_consumer.non_ready_usages)
+
+        @telemetry_api.record_init(fornat_init_config(init_config))
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      private
+
+      def fornat_init_config(init)
+        {
+          oM: init.om,
+          sE: init.se,
+          st: init.st,
+          rR: {
+            sp: init.rr.sp,
+            se: init.rr.se,
+            im: init.rr.im,
+            ev: init.rr.ev,
+            te: init.rr.te
+          },
+          iQ: init.iq,
+          eQ: init.eq,
+          iM: init.im,
+          uO: {
+            s: init.uo.s,
+            e: init.uo.e,
+            a: init.uo.a,
+            st: init.uo.st,
+            t: init.uo.t
+          },
+          iL: init.il,
+          hP: init.hp,
+          aF: init.af,
+          rF: init.rf,
+          tR: init.tr,
+          bT: init.bt,
+          nR: init.nr,
+          t: init.t,
+          i: init.i,
+          fsT: init.fsT,
+          fsI: init.fsI
+        }
+      end
+
+      def format_stats(usage)
+        {
+          lS: usage.ls.to_h,
+          mL: {
+            t: usage.ml[Telemetry::Domain::Constants::TREATMENT],
+            ts: usage.ml[Telemetry::Domain::Constants::TREATMENTS],
+            tc: usage.ml[Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG],
+            tcs: usage.ml[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG],
+            tf: usage.ml[Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET],
+            tfs: usage.ml[Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS],
+            tcf: usage.ml[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET],
+            tcfs: usage.ml[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS],
+            tr: usage.ml[Telemetry::Domain::Constants::TRACK]
+          },
+          mE: {
+            t: usage.me[Telemetry::Domain::Constants::TREATMENT],
+            ts: usage.me[Telemetry::Domain::Constants::TREATMENTS],
+            tc: usage.me[Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG],
+            tcs: usage.me[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG],
+            tf: usage.me[Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET],
+            tfs: usage.me[Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS],
+            tcf: usage.me[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET],
+            tcfs: usage.me[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS],
+            tr: usage.me[Telemetry::Domain::Constants::TRACK]
+          },
+          hE: {
+            sp: usage.he.sp,
+            se: usage.he.se,
+            im: usage.he.im,
+            ic: usage.he.ic,
+            ev: usage.he.ev,
+            te: usage.he.te,
+            to: usage.he.to
+          },
+          hL: {
+            sp: usage.hl.sp,
+            se: usage.hl.se,
+            im: usage.hl.im,
+            ic: usage.hl.ic,
+            ev: usage.hl.ev,
+            te: usage.hl.te,
+            to: usage.hl.to
+          },
+          tR: usage.tr,
+          aR: usage.ar,
+          iQ: usage.iq,
+          iDe: usage.ide,
+          iDr: usage.idr,
+          spC: usage.spc,
+          seC: usage.sec,
+          skC: usage.skc,
+          sL: usage.sl,
+          eQ: usage.eq,
+          eD: usage.ed,
+          sE: usage.se,
+          t: usage.t,
+          ufs: usage.ufs.to_h
+        }
+      end
+
+      def http_proxy_detected?
+        !ENV['HTTP_PROXY'].nil? || !ENV['HTTPS_PROXY'].nil?
+      end
+
+      def mode
+        case @config.mode
+        when :customer
+          1
+        else
+          0
+        end
+      end
+
+      def impressions_mode
+        case @config.impressions_mode
+        when :optimized
+          0
+        when :debug
+          1
+        else
+          2
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/redis/redis_evaluation_producer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RedisEvaluationProducer
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+
+        @sdk_version = "#{@config.language}-#{@config.version}"
+        @name = @config.machine_name
+        @ip = @config.machine_ip
+      end
+
+      def record_latency(method, bucket)
+        @adapter.hincrby(latency_key, "#{@sdk_version}/#{@name}/#{@ip}/#{method}/#{bucket}", 1)
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_exception(method)
+        @adapter.hincrby(exception_key, "#{@sdk_version}/#{@name}/#{@ip}/#{method}", 1)
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      private
+
+      def latency_key
+        "#{@config.redis_namespace}.telemetry.latencies"
+      end
+
+      def exception_key
+        "#{@config.redis_namespace}.telemetry.exceptions"
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/redis/redis_init_producer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RedisInitProducer
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+      end
+
+      def record_config(config_data)
+        return if config_data.nil?
+
+        data = { t: { oM: config_data.om, st: config_data.st, aF: config_data.af, rF: config_data.rf, t: config_data.t } }
+        field = "#{@config.language}-#{@config.version}/#{@config.machine_name}/#{@config.machine_ip}"
+
+        @adapter.add_to_map(config_key, field, data.to_json)
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_bur_timeout
+        # no-op
+      end
+
+      def record_non_ready_usages
+        # no-op
+      end
+
+      private
+
+      def config_key
+        "#{@config.redis_namespace}.telemetry.init"
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/redis/redis_synchronizer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RedisSynchronizer
+      def initialize(config,
+                     telemetry_init_producer)
+        @config = config
+        @telemetry_init_producer = telemetry_init_producer
+      end
+
+      def synchronize_stats
+        # No-op
+      end
+
+      def synchronize_config(active_factories = nil, redundant_active_factories = nil, tags = nil)
+        active_factories ||= SplitIoClient.split_factory_registry.active_factories
+        redundant_active_factories ||= SplitIoClient.split_factory_registry.redundant_active_factories
+
+        init_config = ConfigInit.new(@config.mode, 'redis', active_factories, redundant_active_factories, tags)
+        @telemetry_init_producer.record_config(init_config)
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/runtime_consumer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RuntimeConsumer
+      extend Forwardable
+      def_delegators :@runtime,
+                     :pop_tags,
+                     :impressions_stats,
+                     :events_stats,
+                     :last_synchronizations,
+                     :pop_http_errors,
+                     :pop_http_latencies,
+                     :pop_auth_rejections,
+                     :pop_token_refreshes,
+                     :pop_streaming_events,
+                     :session_length,
+                     :pop_updates_from_sse
+
+      def initialize(config)
+        @runtime = SplitIoClient::Telemetry::MemoryRuntimeConsumer.new(config)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/runtime_producer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RuntimeProducer
+      extend Forwardable
+      def_delegators :@runtime,
+                     :add_tag,
+                     :record_impressions_stats,
+                     :record_events_stats,
+                     :record_successful_sync,
+                     :record_sync_error,
+                     :record_sync_latency,
+                     :record_auth_rejections,
+                     :record_token_refreshes,
+                     :record_streaming_event,
+                     :record_session_length,
+                     :record_updates_from_sse
+
+      def initialize(config)
+        @runtime = SplitIoClient::Telemetry::MemoryRuntimeProducer.new(config)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/storages/memory.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    module Storages
+      class Memory
+        attr_reader :latencies,
+                    :exceptions,
+                    :factory_counters,
+                    :tags,
+                    :impressions_data_records,
+                    :events_data_records,
+                    :last_synchronization,
+                    :http_errors,
+                    :http_latencies,
+                    :auth_rejections,
+                    :token_refreshes,
+                    :streaming_events,
+                    :session_length,
+                    :updates_from_sse
+
+        def initialize
+          init_latencies
+          init_exceptions
+          init_factory_counters
+          init_impressions_data_records
+          init_events_data_records
+          init_last_synchronization
+          init_http_errors
+          init_http_latencies
+          init_auth_rejections
+          init_token_refreshes
+          init_streaming_events
+          init_session_length
+          init_tags
+          init_updates_from_sse
+        end
+
+        def init_latencies
+          @latencies = Concurrent::Array.new
+          treatment_with_config_by_flag_set_const = Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET
+          treatment_with_config_by_flag_sets_const = Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS
+
+          array_size = BinarySearchLatencyTracker::BUCKETS.length
+          @latencies << { method: Domain::Constants::TREATMENT, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENT_WITH_CONFIG, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS_WITH_CONFIG, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS_BY_FLAG_SET, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS_BY_FLAG_SETS, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: treatment_with_config_by_flag_set_const, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: treatment_with_config_by_flag_sets_const, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TRACK, latencies: Concurrent::Array.new(array_size, 0) }
+        end
+
+        def init_exceptions
+          @exceptions = Concurrent::Array.new
+          treatment_with_config_by_flag_set_const = Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET
+          treatment_with_config_by_flag_sets_const = Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS
+
+          @exceptions << { method: Domain::Constants::TREATMENT, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENT_WITH_CONFIG, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS_WITH_CONFIG, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS_BY_FLAG_SET, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS_BY_FLAG_SETS, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: treatment_with_config_by_flag_set_const, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: treatment_with_config_by_flag_sets_const, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TRACK, exceptions: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_factory_counters
+          @factory_counters = Concurrent::Array.new
+
+          @factory_counters << { action: Domain::Constants::BUR_TIMEOUT, counts: Concurrent::AtomicFixnum.new(0) }
+          @factory_counters << { action: Domain::Constants::NON_READY_USAGES, counts: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_impressions_data_records
+          @impressions_data_records = Concurrent::Array.new
+
+          @impressions_data_records << { type: Domain::Constants::IMPRESSIONS_DEDUPE, value: Concurrent::AtomicFixnum.new(0) }
+          @impressions_data_records << { type: Domain::Constants::IMPRESSIONS_DROPPED, value: Concurrent::AtomicFixnum.new(0) }
+          @impressions_data_records << { type: Domain::Constants::IMPRESSIONS_QUEUED, value: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_events_data_records
+          @events_data_records = Concurrent::Array.new
+
+          @events_data_records << { type: Domain::Constants::EVENTS_DROPPED, value: Concurrent::AtomicFixnum.new(0) }
+          @events_data_records << { type: Domain::Constants::EVENTS_QUEUED, value: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_last_synchronization
+          @last_synchronization = Concurrent::Array.new
+
+          @last_synchronization << { type: Domain::Constants::SPLIT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::SEGMENT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::EVENT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::IMPRESSION_COUNT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::IMPRESSIONS_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::TELEMETRY_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::TOKEN_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_tags
+          @tags = Concurrent::Array.new
+        end
+
+        def init_http_errors
+          @http_errors = Concurrent::Array.new
+
+          @http_errors << { type: Domain::Constants::SPLIT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::SEGMENT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::EVENT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::IMPRESSION_COUNT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::IMPRESSIONS_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::TELEMETRY_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::TOKEN_SYNC, value: Concurrent::Hash.new }
+        end
+
+        def init_http_latencies
+          @http_latencies = Concurrent::Array.new
+
+          array_size = BinarySearchLatencyTracker::BUCKETS.length
+          @http_latencies << { type: Domain::Constants::SPLIT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::SEGMENT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::EVENT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::IMPRESSION_COUNT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::IMPRESSIONS_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::TELEMETRY_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::TOKEN_SYNC, value: Concurrent::Array.new(array_size, 0) }
+        end
+
+        def init_auth_rejections
+          @auth_rejections = Concurrent::AtomicFixnum.new(0)
+        end
+
+        def init_token_refreshes
+          @token_refreshes = Concurrent::AtomicFixnum.new(0)
+        end
+
+        def init_streaming_events
+          @streaming_events = Concurrent::Array.new
+        end
+
+        def init_session_length
+          @session_length = Concurrent::AtomicFixnum.new(0)
+        end
+
+        def init_updates_from_sse
+          @updates_from_sse = Concurrent::Hash.new
+
+          @updates_from_sse[Domain::Constants::SPLITS] = 0
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/sync_task.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class SyncTask
+      def initialize(config, telemetry_synchronizer)
+        @config = config
+        @telemetry_synchronizer = telemetry_synchronizer
+      end
+
+      def call
+        stats_thread
+      end
+
+      private
+
+      def stats_thread
+        @config.threads[:telemetry_stats_sender] = Thread.new { telemetry_sync_task }
+      end
+
+      def telemetry_sync_task
+        @config.logger.info('Starting Telemetry Sync Task')
+
+        loop do
+          sleep(@config.telemetry_refresh_rate)
+
+          @telemetry_synchronizer.synchronize_stats
+        end
+      rescue SplitIoClient::SDKShutdownException
+        @telemetry_synchronizer.synchronize_stats
+
+        @config.logger.info('Posting Telemetry due to shutdown')
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/synchronizer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class Synchronizer
+      extend Forwardable
+      def_delegators :@synchronizer,
+                     :synchronize_config,
+                     :synchronize_stats
+
+      def initialize(config,
+                     telemtry_consumers,
+                     telemetry_init_producer,
+                     repositories,
+                     telemetry_api,
+                     flag_sets,
+                     flag_sets_invalid)
+        @synchronizer = case config.telemetry_adapter.class.to_s
+                        when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+                          SplitIoClient::Telemetry::RedisSynchronizer.new(config,
+                                                                          telemetry_init_producer)
+                        else
+                          SplitIoClient::Telemetry::MemorySynchronizer.new(config,
+                                                                           telemtry_consumers,
+                                                                           repositories,
+                                                                           telemetry_api,
+                                                                           flag_sets,
+                                                                           flag_sets_invalid)
+                        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/utilitites.rb

@@ -37,5 +37,13 @@ module SplitIoClient
 
       interval * random_factor
     end
+
+    def split_bulk_to_send(items, divisions)
+      to_return = []
+      items.to_a.each_slice(divisions) {|bulk|
+        to_return.push(bulk.to_set)
+      }
+      to_return
+    end
   end  
 end