ldclient-rb 3.0.3 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c13b41385d09caf349197da95dc022227f5e143
-  data.tar.gz: d9e5536ac51a27fef6e1bacbdde3385d04c5d599
+  metadata.gz: 65f975d234beca67eed5238b9e693fdfb39de00e
+  data.tar.gz: 93e6c8e3de9f9394f1cf9acb64218fda1b873ff6
 SHA512:
-  metadata.gz: d9af4fc567f889a50dad1011367e6f2abf460f552645e850bd1364f12fd385da62a8f564d7fcb119e87ae51c135e5f0e174e8ecec956b4fce03392f5f927d953
-  data.tar.gz: db400282e1500e4b627b8d9b94df8e60b87aa17756f7ceabeb7801346fd64199b038ae8388c3d4c0fe46ffe5517706670ed605b16e13e93a97129a05534cd2d6
+  metadata.gz: 1aacb9669181a5cee75fcfdad3170a195bd43bb572203251daa0fd892e94ecf95bd8627ee124fa961884a44d38209271e9f9fbb094a7773b123328d33011e6ab
+  data.tar.gz: 12b7baa6f4176b357b11307faf9588a918e34059d1a5bc2fc97e5c6076f25ad1b5d5f13b328b4295d4c1bd4a90dfb3fa02daf75549886948e5311c2b91753bed

data/.circleci/config.yml

@@ -0,0 +1,90 @@
+version: 2
+
+workflows:
+  version: 2
+  test:
+    jobs:
+      - test-misc-rubies
+      - test-2.2
+      - test-2.3
+      - test-2.4
+      - test-jruby-9.1
+
+ruby-docker-template: &ruby-docker-template
+  steps:
+    - checkout
+    - run: |
+        if [[ $CIRCLE_JOB == test-jruby* ]]; then
+          gem install jruby-openssl; # required by bundler, no effect on Ruby MRI
+        fi
+    - run: gem install bundler
+    - run: bundle install
+    - run: mkdir ./rspec
+    - run: bundle exec rspec --format progress --format RspecJunitFormatter -o ./rspec/rspec.xml spec
+    - store_test_results:
+        path: ./rspec
+    - store_artifacts:
+        path: ./rspec
+
+jobs:
+  test-2.2:
+    <<: *ruby-docker-template
+    docker:
+      - image: circleci/ruby:2.2.9-jessie
+      - image: redis
+  test-2.3:
+    <<: *ruby-docker-template
+    docker:
+      - image: circleci/ruby:2.3.6-jessie
+      - image: redis
+  test-2.4:
+    <<: *ruby-docker-template
+    docker:
+      - image: circleci/ruby:2.4.3-jessie
+      - image: redis
+  test-jruby-9.1:
+    <<: *ruby-docker-template
+    docker:
+      - image: circleci/jruby:9-jdk
+      - image: redis
+
+  # The following very slow job uses an Ubuntu container to run the Ruby versions that
+  # CircleCI doesn't provide Docker images for.
+  test-misc-rubies:
+    machine:
+      image: circleci/classic:latest
+    environment:
+      - RUBIES: "ruby-2.1.9 ruby-2.0.0 ruby-1.9.3 jruby-9.0.5.0"
+    steps:
+      - run: sudo apt-get -q update
+      - run: sudo apt-get -qy install redis-server
+      - checkout
+      - run:
+          name: install all Ruby versions
+          command: "parallel rvm install ::: $RUBIES"
+      - run:
+          name: bundle install for all versions
+          shell: /bin/bash -leo pipefail # need -l in order for "rvm use" to work
+          command: |
+            set -e;
+            for i in $RUBIES;
+            do
+              rvm use $i;
+              if [[ $i == jruby* ]]; then
+                gem install jruby-openssl; # required by bundler, no effect on Ruby MRI
+              fi
+              gem install bundler;
+              bundle install;
+              mv Gemfile.lock "Gemfile.lock.$i"
+            done
+      - run:
+          name: run tests for all versions
+          shell: /bin/bash -leo pipefail
+          command: |
+            set -e;
+            for i in $RUBIES;
+            do
+              rvm use $i;
+              cp "Gemfile.lock.$i" Gemfile.lock;
+              bundle exec rspec spec;
+            done

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [4.0.0] - 2018-05-10
+
+### Changed:
+- To reduce the network bandwidth used for analytics events, feature request events are now sent as counters rather than individual events, and user details are now sent only at intervals rather than in each event. These behaviors can be modified through the LaunchDarkly UI and with the new configuration option `inline_users_in_events`. For more details, see [Analytics Data Stream Reference](https://docs.launchdarkly.com/v2.0/docs/analytics-data-stream-reference).
+
+### Removed:
+- JRuby 1.7 is no longer supported.
+- Greatly reduced the number of indirect gem dependencies by removing `moneta`, which was previously a requirement for the Redis feature store.
+
+
 ## [3.0.3] - 2018-03-23
 ## Fixed
 - In the Redis feature store, fixed a synchronization problem that could cause a feature flag update to be missed if several of them happened in rapid succession.

data/README.md

@@ -4,7 +4,6 @@ LaunchDarkly SDK for Ruby
 [![Gem Version](https://badge.fury.io/rb/ldclient-rb.svg)](http://badge.fury.io/rb/ldclient-rb)
 
 [![Circle CI](https://circleci.com/gh/launchdarkly/ruby-client/tree/master.svg?style=svg)](https://circleci.com/gh/launchdarkly/ruby-client/tree/master)
-[![Code Climate](https://codeclimate.com/github/launchdarkly/ruby-client/badges/gpa.svg)](https://codeclimate.com/github/launchdarkly/ruby-client)
 [![Test Coverage](https://codeclimate.com/github/launchdarkly/ruby-client/badges/coverage.svg)](https://codeclimate.com/github/launchdarkly/ruby-client/coverage)
 [![security](https://hakiri.io/github/launchdarkly/ruby-client/master.svg)](https://hakiri.io/github/launchdarkly/ruby-client/master)
 

data/ldclient-rb.gemspec

@@ -22,12 +22,18 @@ Gem::Specification.new do |spec|
   spec.extensions    = 'ext/mkrf_conf.rb'
 
   spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.2"
   spec.add_development_dependency "codeclimate-test-reporter", "~> 0"
   spec.add_development_dependency "redis", "~> 3.3.5"
   spec.add_development_dependency "connection_pool", ">= 2.1.2"
-  spec.add_development_dependency "moneta", "~> 1.0.0"
+  if RUBY_VERSION >= "2.0.0"
+    spec.add_development_dependency "rake", "~> 10.0"
+    spec.add_development_dependency "rspec_junit_formatter", "~> 0.3.0"
+  else
+    spec.add_development_dependency "rake", "12.1.0"
+    # higher versions of rake fail to install in JRuby 1.7
+  end
+  spec.add_development_dependency "timecop", "~> 0.9.1"
 
   spec.add_runtime_dependency "json", [">= 1.8", "< 3"]
   if RUBY_VERSION >= "2.1.0"

data/lib/ldclient-rb.rb

@@ -2,13 +2,17 @@ require "ldclient-rb/version"
 require "ldclient-rb/evaluation"
 require "ldclient-rb/ldclient"
 require "ldclient-rb/cache_store"
+require "ldclient-rb/expiring_cache"
 require "ldclient-rb/memoized_value"
 require "ldclient-rb/in_memory_store"
 require "ldclient-rb/config"
 require "ldclient-rb/newrelic"
 require "ldclient-rb/stream"
 require "ldclient-rb/polling"
-require "ldclient-rb/event_serializer"
+require "ldclient-rb/user_filter"
+require "ldclient-rb/simple_lru_cache"
+require "ldclient-rb/non_blocking_thread_pool"
+require "ldclient-rb/event_summarizer"
 require "ldclient-rb/events"
 require "ldclient-rb/redis_store"
 require "ldclient-rb/requestor"

data/lib/ldclient-rb/config.rb

@@ -54,7 +54,15 @@ module LaunchDarkly
     # @option opts [Boolean] :send_events (true) Whether or not to send events back to LaunchDarkly.
     #   This differs from `offline` in that it affects only the sending of client-side events, not
     #   streaming or polling for events from the server.
-    #
+    # @option opts [Integer] :user_keys_capacity (1000) The number of user keys that the event processor
+    #   can remember at any one time, so that duplicate user details will not be sent in analytics events.
+    # @option opts [Float] :user_keys_flush_interval (300) The interval in seconds at which the event
+    #   processor will reset its set of known user keys.
+    # @option opts [Boolean] :inline_users_in_events (false) Whether to include full user details in every
+    #   analytics event. By default, events will only include the user key, except for one "index" event
+    #   that provides the full details for the user.
+    # @option opts [Object] :update_processor An object that will receive feature flag data from LaunchDarkly.
+    #   Defaults to either the streaming or the polling processor, can be customized for tests.
     # @return [type] [description]
     # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
     def initialize(opts = {})
@@ -76,6 +84,10 @@ module LaunchDarkly
       @all_attributes_private = opts[:all_attributes_private] || false
       @private_attribute_names = opts[:private_attribute_names] || []
       @send_events = opts.has_key?(:send_events) ? opts[:send_events] : Config.default_send_events
+      @user_keys_capacity = opts[:user_keys_capacity] || Config.default_user_keys_capacity
+      @user_keys_flush_interval = opts[:user_keys_flush_interval] || Config.default_user_keys_flush_interval
+      @inline_users_in_events = opts[:inline_users_in_events] || false
+      @update_processor = opts[:update_processor]
     end
 
     #
@@ -186,6 +198,26 @@ module LaunchDarkly
     #
     attr_reader :send_events
 
+    #
+    # The number of user keys that the event processor can remember at any one time, so that
+    # duplicate user details will not be sent in analytics events.
+    #
+    attr_reader :user_keys_capacity
+
+    #
+    # The interval in seconds at which the event processor will reset its set of known user keys.
+    #
+    attr_reader :user_keys_flush_interval
+
+    #
+    # Whether to include full user details in every
+    # analytics event. By default, events will only include the user key, except for one "index" event
+    # that provides the full details for the user.
+    #
+    attr_reader :inline_users_in_events
+
+    attr_reader :update_processor
+    
     #
     # The default LaunchDarkly client configuration. This configuration sets
     # reasonable defaults for most users.
@@ -264,5 +296,13 @@ module LaunchDarkly
     def self.default_send_events
       true
     end
+
+    def self.default_user_keys_capacity
+      1000
+    end
+
+    def self.default_user_keys_flush_interval
+      300
+    end
   end
 end

data/lib/ldclient-rb/evaluation.rb

@@ -114,7 +114,7 @@ module LaunchDarkly
     # generated during prerequisite evaluation. Raises EvaluationError if the flag is not well-formed
     # Will return nil, but not raise an exception, indicating that the rules (including fallthrough) did not match
     # In that case, the caller should return the default value.
-    def evaluate(flag, user, store)
+    def evaluate(flag, user, store, logger)
       if flag.nil?
         raise EvaluationError, "Flag does not exist"
       end
@@ -126,20 +126,23 @@ module LaunchDarkly
       events = []
 
       if flag[:on]
-        res = eval_internal(flag, user, store, events)
-
-        return { value: res, events: events } if !res.nil?
+        res = eval_internal(flag, user, store, events, logger)
+        if !res.nil?
+          res[:events] = events
+          return res
+        end
       end
 
-      if !flag[:offVariation].nil? && flag[:offVariation] < flag[:variations].length
-        value = flag[:variations][flag[:offVariation]]
-        return { value: value, events: events }
+      offVariation = flag[:offVariation]
+      if !offVariation.nil? && offVariation < flag[:variations].length
+        value = flag[:variations][offVariation]
+        return { variation: offVariation, value: value, events: events }
       end
 
-      { value: nil, events: events }
+      { variation: nil, value: nil, events: events }
     end
 
-    def eval_internal(flag, user, store, events)
+    def eval_internal(flag, user, store, events, logger)
       failed_prereq = false
       # Evaluate prerequisites, if any
       (flag[:prerequisites] || []).each do |prerequisite|
@@ -149,14 +152,23 @@ module LaunchDarkly
           failed_prereq = true
         else
           begin
-            prereq_res = eval_internal(prereq_flag, user, store, events)
-            variation = get_variation(prereq_flag, prerequisite[:variation])
-            events.push(kind: "feature", key: prereq_flag[:key], value: prereq_res, version: prereq_flag[:version], prereqOf: flag[:key])
-            if prereq_res.nil? || prereq_res != variation
+            prereq_res = eval_internal(prereq_flag, user, store, events, logger)
+            event = {
+              kind: "feature",
+              key: prereq_flag[:key],
+              variation: prereq_res.nil? ? nil : prereq_res[:variation],
+              value: prereq_res.nil? ? nil : prereq_res[:value],
+              version: prereq_flag[:version],
+              prereqOf: flag[:key],
+              trackEvents: prereq_flag[:trackEvents],
+              debugEventsUntilDate: prereq_flag[:debugEventsUntilDate]
+            }
+            events.push(event)
+            if prereq_res.nil? || prereq_res[:variation] != prerequisite[:variation]
               failed_prereq = true
             end
           rescue => exn
-            @config.logger.error { "[LDClient] Error evaluating prerequisite: #{exn.inspect}" }
+            logger.error { "[LDClient] Error evaluating prerequisite: #{exn.inspect}" }
             failed_prereq = true
           end
         end
@@ -175,7 +187,9 @@ module LaunchDarkly
       # Check user target matches
       (flag[:targets] || []).each do |target|
         (target[:values] || []).each do |value|
-          return get_variation(flag, target[:variation]) if value == user[:key]
+          if value == user[:key]
+            return { variation: target[:variation], value: get_variation(flag, target[:variation]) }
+          end
         end
       end
     
@@ -245,7 +259,7 @@ module LaunchDarkly
 
     def variation_for_user(rule, user, flag)
       if !rule[:variation].nil? # fixed variation
-        return get_variation(flag, rule[:variation])
+        return { variation: rule[:variation], value: get_variation(flag, rule[:variation]) }
       elsif !rule[:rollout].nil? # percentage rollout
         rollout = rule[:rollout]
         bucket_by = rollout[:bucketBy].nil? ? "key" : rollout[:bucketBy]
@@ -253,7 +267,9 @@ module LaunchDarkly
         sum = 0;
         rollout[:variations].each do |variate|
           sum += variate[:weight].to_f / 100000.0
-          return get_variation(flag, variate[:variation]) if bucket < sum
+          if bucket < sum
+            return { variation: variate[:variation], value: get_variation(flag, variate[:variation]) }
+          end
         end
         nil
       else # the rule isn't well-formed

data/lib/ldclient-rb/event_summarizer.rb

@@ -0,0 +1,52 @@
+
+module LaunchDarkly
+  EventSummary = Struct.new(:start_date, :end_date, :counters)
+
+  # Manages the state of summarizable information for the EventProcessor, including the
+  # event counters and user deduplication. Note that the methods of this class are
+  # deliberately not thread-safe; the EventProcessor is responsible for enforcing
+  # synchronization across both the summarizer and the event queue.
+  class EventSummarizer
+    def initialize
+      clear
+    end
+
+    # Adds this event to our counters, if it is a type of event we need to count.
+    def summarize_event(event)
+      if event[:kind] == "feature"
+        counter_key = {
+          key: event[:key],
+          version: event[:version],
+          variation: event[:variation]
+        }
+        c = @counters[counter_key]
+        if c.nil?
+          @counters[counter_key] = {
+            value: event[:value],
+            default: event[:default],
+            count: 1
+          }
+        else
+          c[:count] = c[:count] + 1
+        end
+        time = event[:creationDate]
+        if !time.nil?
+          @start_date = time if @start_date == 0 || time < @start_date
+          @end_date = time if time > @end_date
+        end
+      end
+    end
+
+    # Returns a snapshot of the current summarized event data, and resets this state.
+    def snapshot
+      ret = EventSummary.new(@start_date, @end_date, @counters)
+      ret
+    end
+
+    def clear
+      @start_date = 0
+      @end_date = 0
+      @counters = {}
+    end
+  end
+end

data/lib/ldclient-rb/events.rb

@@ -1,94 +1,426 @@
+require "concurrent"
 require "concurrent/atomics"
+require "concurrent/executors"
 require "thread"
+require "time"
 require "faraday"
 
 module LaunchDarkly
+  MAX_FLUSH_WORKERS = 5
+  CURRENT_SCHEMA_VERSION = 3
+
+  class NullEventProcessor
+    def add_event(event)
+    end
+
+    def flush
+    end
+
+    def stop
+    end
+  end
+
+  class EventMessage
+    def initialize(event)
+      @event = event
+    end
+    attr_reader :event
+  end
+
+  class FlushMessage
+  end
+
+  class FlushUsersMessage
+  end
+
+  class SynchronousMessage
+    def initialize
+      @reply = Concurrent::Semaphore.new(0)
+    end
+    
+    def completed
+      @reply.release
+    end
+
+    def wait_for_completion
+      @reply.acquire
+    end
+  end
+
+  class TestSyncMessage < SynchronousMessage
+  end
+
+  class StopMessage < SynchronousMessage
+  end
+
   class EventProcessor
-    def initialize(sdk_key, config)
+    def initialize(sdk_key, config, client = nil)
       @queue = Queue.new
-      @sdk_key = sdk_key
-      @config = config
-      @serializer = EventSerializer.new(config)
-      @client = Faraday.new
+      @flush_task = Concurrent::TimerTask.new(execution_interval: config.flush_interval) do
+        @queue << FlushMessage.new
+      end
+      @flush_task.execute
+      @users_flush_task = Concurrent::TimerTask.new(execution_interval: config.user_keys_flush_interval) do
+        @queue << FlushUsersMessage.new
+      end
+      @users_flush_task.execute
       @stopped = Concurrent::AtomicBoolean.new(false)
-      @worker = create_worker if @config.send_events
+      
+      EventDispatcher.new(@queue, sdk_key, config, client)
+    end
+
+    def add_event(event)
+      event[:creationDate] = (Time.now.to_f * 1000).to_i
+      @queue << EventMessage.new(event)
     end
 
-    def alive?
-      !@stopped.value
+    def flush
+      # flush is done asynchronously
+      @queue << FlushMessage.new
     end
 
     def stop
+      # final shutdown, which includes a final flush, is done synchronously
       if @stopped.make_true
-        # There seems to be no such thing as "close" in Faraday: https://github.com/lostisland/faraday/issues/241
-        if !@worker.nil? && @worker.alive?
-          @worker.raise "shutting down client"
-        end
+        @flush_task.shutdown
+        @users_flush_task.shutdown
+        @queue << FlushMessage.new
+        stop_msg = StopMessage.new
+        @queue << stop_msg
+        stop_msg.wait_for_completion
       end
     end
 
-    def create_worker
-      Thread.new do
-        while !@stopped.value do
-          begin
-            flush
-            sleep(@config.flush_interval)
-          rescue StandardError => exn
-            log_exception(__method__.to_s, exn)
+    # exposed only for testing
+    def wait_until_inactive
+      sync_msg = TestSyncMessage.new
+      @queue << sync_msg
+      sync_msg.wait_for_completion
+    end
+  end
+
+  class EventDispatcher
+    def initialize(queue, sdk_key, config, client)
+      @sdk_key = sdk_key
+      @config = config
+      @client = client ? client : Faraday.new
+      @user_keys = SimpleLRUCacheSet.new(config.user_keys_capacity)
+      @formatter = EventOutputFormatter.new(config)
+      @disabled = Concurrent::AtomicBoolean.new(false)
+      @last_known_past_time = Concurrent::AtomicFixnum.new(0)
+
+      buffer = EventBuffer.new(config.capacity, config.logger)
+      flush_workers = NonBlockingThreadPool.new(MAX_FLUSH_WORKERS)
+
+      Thread.new { main_loop(queue, buffer, flush_workers) }
+    end
+
+    private
+
+    def now_millis()
+      (Time.now.to_f * 1000).to_i
+    end
+
+    def main_loop(queue, buffer, flush_workers)
+      running = true
+      while running do
+        begin
+          message = queue.pop
+          case message
+          when EventMessage
+            dispatch_event(message.event, buffer)
+          when FlushMessage
+            trigger_flush(buffer, flush_workers)
+          when FlushUsersMessage
+            @user_keys.clear
+          when TestSyncMessage
+            synchronize_for_testing(flush_workers)
+            message.completed
+          when StopMessage
+            do_shutdown(flush_workers)
+            running = false
+            message.completed
           end
+        rescue => e
+          @config.logger.warn { "[LDClient] Unexpected error in event processor: #{e.inspect}. \nTrace: #{e.backtrace}" }
         end
       end
     end
 
-    def post_flushed_events(events)
-      res = @client.post (@config.events_uri + "/bulk") do |req|
-        req.headers["Authorization"] = @sdk_key
-        req.headers["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
-        req.headers["Content-Type"] = "application/json"
-        req.body = @serializer.serialize_events(events)
-        req.options.timeout = @config.read_timeout
-        req.options.open_timeout = @config.connect_timeout
+    def do_shutdown(flush_workers)
+      flush_workers.shutdown
+      flush_workers.wait_for_termination
+      # There seems to be no such thing as "close" in Faraday: https://github.com/lostisland/faraday/issues/241
+    end
+
+    def synchronize_for_testing(flush_workers)
+      # Used only by unit tests. Wait until all active flush workers have finished.
+      flush_workers.wait_all
+    end
+
+    def dispatch_event(event, buffer)
+      return if @disabled.value
+
+      # Always record the event in the summary.
+      buffer.add_to_summary(event)
+
+      # Decide whether to add the event to the payload. Feature events may be added twice, once for
+      # the event (if tracked) and once for debugging.
+      will_add_full_event = false
+      debug_event = nil
+      if event[:kind] == "feature"
+        will_add_full_event = event[:trackEvents]
+        if should_debug_event(event)
+          debug_event = event.clone
+          debug_event[:debug] = true
+        end
+      else
+        will_add_full_event = true
       end
-      if res.status < 200 || res.status >= 300
-        @config.logger.error { "[LDClient] Unexpected status code while processing events: #{res.status}" }
-        if res.status == 401
-          @config.logger.error { "[LDClient] Received 401 error, no further events will be posted since SDK key is invalid" }
-          stop
+
+      # For each user we haven't seen before, we add an index event - unless this is already
+      # an identify event for that user.
+      if !(will_add_full_event && @config.inline_users_in_events)
+        if event.has_key?(:user) && !notice_user(event[:user]) && event[:kind] != "identify"
+          buffer.add_event({
+            kind: "index",
+            creationDate: event[:creationDate],
+            user: event[:user]
+          })
         end
       end
+
+      buffer.add_event(event) if will_add_full_event
+      buffer.add_event(debug_event) if !debug_event.nil?
     end
 
-    def flush
-      return if @offline || !@config.send_events
-      events = []
-      begin
-        loop do
-          events << @queue.pop(true)
+    # Add to the set of users we've noticed, and return true if the user was already known to us.
+    def notice_user(user)
+      if user.nil? || !user.has_key?(:key)
+        true
+      else
+        @user_keys.add(user[:key])
+      end
+    end
+
+    def should_debug_event(event)
+      debug_until = event[:debugEventsUntilDate]
+      if !debug_until.nil?
+        last_past = @last_known_past_time.value
+        debug_until > last_past && debug_until > now_millis
+      else
+        false
+      end
+    end
+
+    def trigger_flush(buffer, flush_workers)
+      if @disabled.value
+        return
+      end
+
+      payload = buffer.get_payload  
+      if !payload.events.empty? || !payload.summary.counters.empty?
+        # If all available worker threads are busy, success will be false and no job will be queued.
+        success = flush_workers.post do
+          resp = EventPayloadSendTask.new.run(@sdk_key, @config, @client, payload, @formatter)
+          handle_response(resp) if !resp.nil?
         end
-      rescue ThreadError
+        buffer.clear if success # Reset our internal state, these events now belong to the flush worker
       end
+    end
 
-      if !events.empty? && !@stopped.value
-        post_flushed_events(events)
+    def handle_response(res)
+      if res.status == 401
+        @config.logger.error { "[LDClient] Received 401 error, no further events will be posted since SDK key is invalid" }
+        @disabled.value = true
+      else
+        if !res.headers.nil? && res.headers.has_key?("Date")
+          begin
+            res_time = (Time.httpdate(res.headers["Date"]).to_f * 1000).to_i
+            @last_known_past_time.value = res_time
+          rescue ArgumentError
+          end
+        end
       end
     end
+  end
+
+  FlushPayload = Struct.new(:events, :summary)
+
+  class EventBuffer
+    def initialize(capacity, logger)
+      @capacity = capacity
+      @logger = logger
+      @capacity_exceeded = false
+      @events = []
+      @summarizer = EventSummarizer.new
+    end
 
     def add_event(event)
-      return if @offline || !@config.send_events || @stopped.value
+      if @events.length < @capacity
+        @logger.debug { "[LDClient] Enqueueing event: #{event.to_json}" }
+        @events.push(event)
+        @capacity_exceeded = false
+      else
+        if !@capacity_exceeded
+          @capacity_exceeded = true
+          @logger.warn { "[LDClient] Exceeded event queue capacity. Increase capacity to avoid dropping events." }
+        end
+      end
+    end
+
+    def add_to_summary(event)
+      @summarizer.summarize_event(event)
+    end
 
-      if @queue.length < @config.capacity
-        event[:creationDate] = (Time.now.to_f * 1000).to_i
-        @config.logger.debug { "[LDClient] Enqueueing event: #{event.to_json}" }
-        @queue.push(event)
+    def get_payload
+      return FlushPayload.new(@events, @summarizer.snapshot)
+    end
+
+    def clear
+      @events = []
+      @summarizer.clear
+    end
+  end
 
-        if !@worker.alive?
-          @worker = create_worker
+  class EventPayloadSendTask
+    def run(sdk_key, config, client, payload, formatter)
+      events_out = formatter.make_output_events(payload.events, payload.summary)
+      res = nil
+      body = events_out.to_json
+      (0..1).each do |attempt|
+        if attempt > 0
+          config.logger.warn { "[LDClient] Will retry posting events after 1 second" }
+          sleep(1)
         end
+        begin
+          config.logger.debug { "[LDClient] sending #{events_out.length} events: #{body}" }
+          res = client.post (config.events_uri + "/bulk") do |req|
+            req.headers["Authorization"] = sdk_key
+            req.headers["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
+            req.headers["Content-Type"] = "application/json"
+            req.headers["X-LaunchDarkly-Event-Schema"] = CURRENT_SCHEMA_VERSION.to_s
+            req.body = body
+            req.options.timeout = config.read_timeout
+            req.options.open_timeout = config.connect_timeout
+          end
+        rescue StandardError => exn
+          config.logger.warn { "[LDClient] Error flushing events: #{exn.inspect}." }
+          next
+        end
+        if res.status < 200 || res.status >= 300
+          config.logger.error { "[LDClient] Unexpected status code while processing events: #{res.status}" }
+          if res.status >= 500
+            next
+          end
+        end
+        break
+      end
+      # used up our retries, return the last response if any
+      res
+    end
+  end
+
+  class EventOutputFormatter
+    def initialize(config)
+      @inline_users = config.inline_users_in_events
+      @user_filter = UserFilter.new(config)
+    end
+
+    # Transforms events into the format used for event sending.
+    def make_output_events(events, summary)
+      events_out = events.map { |e| make_output_event(e) }
+      if !summary.counters.empty?
+        events_out.push(make_summary_event(summary))
+      end
+      events_out
+    end
+
+    private
+
+    def make_output_event(event)
+      case event[:kind]
+      when "feature"
+        is_debug = event[:debug]
+        out = {
+          kind: is_debug ? "debug" : "feature",
+          creationDate: event[:creationDate],
+          key: event[:key],
+          value: event[:value]
+        }
+        out[:default] = event[:default] if event.has_key?(:default)
+        out[:variation] = event[:variation] if event.has_key?(:variation)
+        out[:version] = event[:version] if event.has_key?(:version)
+        out[:prereqOf] = event[:prereqOf] if event.has_key?(:prereqOf)
+        if @inline_users || is_debug
+          out[:user] = @user_filter.transform_user_props(event[:user])
+        else
+          out[:userKey] = event[:user].nil? ? nil : event[:user][:key]
+        end
+        out
+      when "identify"
+        {
+          kind: "identify",
+          creationDate: event[:creationDate],
+          key: event[:user].nil? ? nil : event[:user][:key],
+          user: @user_filter.transform_user_props(event[:user])
+        }
+      when "custom"
+        out = {
+          kind: "custom",
+          creationDate: event[:creationDate],
+          key: event[:key]
+        }
+        out[:data] = event[:data] if event.has_key?(:data)
+        if @inline_users
+          out[:user] = @user_filter.transform_user_props(event[:user])
+        else
+          out[:userKey] = event[:user].nil? ? nil : event[:user][:key]
+        end
+        out
+      when "index"
+        {
+          kind: "index",
+          creationDate: event[:creationDate],
+          user: @user_filter.transform_user_props(event[:user])
+        }
       else
-        @config.logger.warn { "[LDClient] Exceeded event queue capacity. Increase capacity to avoid dropping events." }
+        event
       end
     end
 
-    private :create_worker, :post_flushed_events
+    # Transforms the summary data into the format used for event sending.
+    def make_summary_event(summary)
+      flags = {}
+      summary[:counters].each { |ckey, cval|
+        flag = flags[ckey[:key]]
+        if flag.nil?
+          flag = {
+            default: cval[:default],
+            counters: []
+          }
+          flags[ckey[:key]] = flag
+        end
+        c = {
+          value: cval[:value],
+          count: cval[:count]
+        }
+        if !ckey[:variation].nil?
+          c[:variation] = ckey[:variation]
+        end
+        if ckey[:version].nil?
+          c[:unknown] = true
+        else
+          c[:version] = ckey[:version]
+        end
+        flag[:counters].push(c)
+      }
+      {
+        kind: "summary",
+        startDate: summary[:start_date],
+        endDate: summary[:end_date],
+        features: flags
+      }
+    end
   end
 end