launchdarkly-server-sdk 5.5.11 → 5.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3726dd61c5d5366f734b12e9803ea528ec03ccb9
-  data.tar.gz: ea169915fd5092048cae20bc45494ba8a6a18d82
+  metadata.gz: 6711ad265d73300d06cb1a287c76ae1981e9c1e7
+  data.tar.gz: 27c72e98745eb679e91a0691766991277490995f
 SHA512:
-  metadata.gz: 26cfea25eced467021ecfab5b76390a35ef3d5a3b3fbccc7322e427f452c1e7d13e1fd22abe15bb940b4a9e01dd7a38123e5a9b2ddc41b9a1ec97447986590bc
-  data.tar.gz: d0c2420bda1218e2785f9c54ab134c4ee870a1883d887f16160fa0af83fa662c9831c20c191c8f0692b9ed6353868052662675f2d3a0dc136a65df2f97b4d0f2
+  metadata.gz: 5f0a6c09dd0cff741849392b32d75ac469a08116d918ebaeff2020693d7971bdf5082fee42fe310298fdfb20051da3547e98964fec88c952a3351d1642b5a4c8
+  data.tar.gz: 4f4474d63efe13be2db68977b51b1f7d65217415f740823e439568980c28713e0bbdcaab83a7e23c32d0889eed32fcd6cf0778d8dd1e15e0d573994081219157

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [5.5.12] - 2019-08-05
+### Fixed:
+- Under conditions where analytics events are being generated at an extremely high rate (for instance, if an application is evaluating a flag repeatedly in a tight loop on many threads), it was possible for the internal event processing logic to fall behind on processing the events, causing them to use more and more memory. The logic has been changed to drop events if necessary so that besides the existing limit on the number of events waiting to be sent to LaunchDarkly (`config.capacity`), the same limit also applies on the number of events that are waiting to be processed by the worker thread that decides whether or not to send them to LaunchDarkly. If that limit is exceeded, this warning message will be logged once: "Events are being produced faster than they can be processed; some events will be dropped". Under normal conditions this should never happen; this change is meant to avoid a concurrency bottleneck in applications that are already so busy that thread starvation is likely.
+
 ## [5.5.11] - 2019-07-24
 ### Fixed:
 - `FileDataSource` was using `YAML.load`, which has a known [security vulnerability](https://trailofbits.github.io/rubysec/yaml/index.html). This has been changed to use `YAML.safe_load`, which will refuse to parse any files that contain the `!` directives used in this type of attack. This issue does not affect any applications that do not use `FileDataSource` (which is meant for testing purposes, not production use). ([#139](https://github.com/launchdarkly/ruby-server-sdk/issues/139))

data/lib/ldclient-rb/events.rb

@@ -4,6 +4,23 @@ require "concurrent/executors"
 require "thread"
 require "time"
 
+#
+# Analytics event processing in the SDK involves several components. The purpose of this design is to
+# minimize overhead on the application threads that are generating analytics events.
+#
+# EventProcessor receives an analytics event from the SDK client, on an application thread. It places
+# the event in a bounded queue, the "inbox", and immediately returns.
+#
+# On a separate worker thread, EventDispatcher consumes events from the inbox. These are considered
+# "input events" because they may or may not actually be sent to LaunchDarkly; most flag evaluation
+# events are not sent, but are counted and the counters become part of a single summary event.
+# EventDispatcher updates those counters, creates "index" events for any users that have not been seen
+# recently, and places any events that will be sent to LaunchDarkly into the "outbox" queue.
+#
+# When it is time to flush events to LaunchDarkly, the contents of the outbox are handed off to
+# another worker thread which sends the HTTP request.
+#
+
 module LaunchDarkly
   MAX_FLUSH_WORKERS = 5
   CURRENT_SCHEMA_VERSION = 3
@@ -68,28 +85,30 @@ module LaunchDarkly
   # @private
   class EventProcessor
     def initialize(sdk_key, config, client = nil)
-      @queue = Queue.new
+      @logger = config.logger
+      @inbox = SizedQueue.new(config.capacity)
       @flush_task = Concurrent::TimerTask.new(execution_interval: config.flush_interval) do
-        @queue << FlushMessage.new
+        post_to_inbox(FlushMessage.new)
       end
       @flush_task.execute
       @users_flush_task = Concurrent::TimerTask.new(execution_interval: config.user_keys_flush_interval) do
-        @queue << FlushUsersMessage.new
+        post_to_inbox(FlushUsersMessage.new)
       end
       @users_flush_task.execute
       @stopped = Concurrent::AtomicBoolean.new(false)
-      
-      EventDispatcher.new(@queue, sdk_key, config, client)
+      @inbox_full = Concurrent::AtomicBoolean.new(false)
+
+      EventDispatcher.new(@inbox, sdk_key, config, client)
     end
 
     def add_event(event)
       event[:creationDate] = (Time.now.to_f * 1000).to_i
-      @queue << EventMessage.new(event)
+      post_to_inbox(EventMessage.new(event))
     end
 
     def flush
       # flush is done asynchronously
-      @queue << FlushMessage.new
+      post_to_inbox(FlushMessage.new)
     end
 
     def stop
@@ -97,9 +116,11 @@ module LaunchDarkly
       if @stopped.make_true
         @flush_task.shutdown
         @users_flush_task.shutdown
-        @queue << FlushMessage.new
+        # Note that here we are not calling post_to_inbox, because we *do* want to wait if the inbox
+        # is full; an orderly shutdown can't happen unless these messages are received.
+        @inbox << FlushMessage.new
         stop_msg = StopMessage.new
-        @queue << stop_msg
+        @inbox << stop_msg
         stop_msg.wait_for_completion
       end
     end
@@ -107,14 +128,30 @@ module LaunchDarkly
     # exposed only for testing
     def wait_until_inactive
       sync_msg = TestSyncMessage.new
-      @queue << sync_msg
+      @inbox << sync_msg
       sync_msg.wait_for_completion
     end
+
+    private
+
+    def post_to_inbox(message)
+      begin
+        @inbox.push(message, non_block=true)
+      rescue ThreadError
+        # If the inbox is full, it means the EventDispatcher thread is seriously backed up with not-yet-processed
+        # events. This is unlikely, but if it happens, it means the application is probably doing a ton of flag
+        # evaluations across many threads-- so if we wait for a space in the inbox, we risk a very serious slowdown
+        # of the app. To avoid that, we'll just drop the event. The log warning about this will only be shown once.
+        if @inbox_full.make_true
+          @logger.warn { "[LDClient] Events are being produced faster than they can be processed; some events will be dropped" }
+        end
+      end
+    end
   end
 
   # @private
   class EventDispatcher
-    def initialize(queue, sdk_key, config, client)
+    def initialize(inbox, sdk_key, config, client)
       @sdk_key = sdk_key
       @config = config
 
@@ -129,10 +166,10 @@ module LaunchDarkly
       @disabled = Concurrent::AtomicBoolean.new(false)
       @last_known_past_time = Concurrent::AtomicReference.new(0)
 
-      buffer = EventBuffer.new(config.capacity, config.logger)
+      outbox = EventBuffer.new(config.capacity, config.logger)
       flush_workers = NonBlockingThreadPool.new(MAX_FLUSH_WORKERS)
 
-      Thread.new { main_loop(queue, buffer, flush_workers) }
+      Thread.new { main_loop(inbox, outbox, flush_workers) }
     end
 
     private
@@ -141,16 +178,16 @@ module LaunchDarkly
       (Time.now.to_f * 1000).to_i
     end
 
-    def main_loop(queue, buffer, flush_workers)
+    def main_loop(inbox, outbox, flush_workers)
       running = true
       while running do
         begin
-          message = queue.pop
+          message = inbox.pop
           case message
           when EventMessage
-            dispatch_event(message.event, buffer)
+            dispatch_event(message.event, outbox)
           when FlushMessage
-            trigger_flush(buffer, flush_workers)
+            trigger_flush(outbox, flush_workers)
           when FlushUsersMessage
             @user_keys.clear
           when TestSyncMessage
@@ -181,11 +218,11 @@ module LaunchDarkly
       flush_workers.wait_all
     end
 
-    def dispatch_event(event, buffer)
+    def dispatch_event(event, outbox)
       return if @disabled.value
 
       # Always record the event in the summary.
-      buffer.add_to_summary(event)
+      outbox.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.
@@ -205,7 +242,7 @@ module LaunchDarkly
       # 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({
+          outbox.add_event({
             kind: "index",
             creationDate: event[:creationDate],
             user: event[:user]
@@ -213,8 +250,8 @@ module LaunchDarkly
         end
       end
 
-      buffer.add_event(event) if will_add_full_event
-      buffer.add_event(debug_event) if !debug_event.nil?
+      outbox.add_event(event) if will_add_full_event
+      outbox.add_event(debug_event) if !debug_event.nil?
     end
 
     # Add to the set of users we've noticed, and return true if the user was already known to us.
@@ -236,12 +273,12 @@ module LaunchDarkly
       end
     end
 
-    def trigger_flush(buffer, flush_workers)
+    def trigger_flush(outbox, flush_workers)
       if @disabled.value
         return
       end
 
-      payload = buffer.get_payload  
+      payload = outbox.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
@@ -252,7 +289,7 @@ module LaunchDarkly
             Util.log_exception(@config.logger, "Unexpected error in event processor", e)
           end
         end
-        buffer.clear if success # Reset our internal state, these events now belong to the flush worker
+        outbox.clear if success # Reset our internal state, these events now belong to the flush worker
       end
     end
 

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "5.5.11"
+  VERSION = "5.5.12"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 5.5.11
+  version: 5.5.12
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-25 00:00:00.000000000 Z
+date: 2019-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb