posthog-ruby 3.13.1 → 3.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecafefeb08db88e91f921ab86cc572b7a0c15a545d778634881ab09a2896a00a
-  data.tar.gz: c4dd831780adcfc7782fa7d18227bae544760bf50f5a702f709d9e052a1c6411
+  metadata.gz: 017e5c02b782e02a2861716768adff003cd203f5996c16e2e8887788f2111fb0
+  data.tar.gz: c952a5e44cb1dc847fec2fca8714c886e601b4112151c083508d69f017f6aa4d
 SHA512:
-  metadata.gz: cbeb255541f1bca9ba929d659bf7448a9ef6fc884c934e8acccf0cc2788e4afd48a82b9ca9f7bdb3d396fa06225dcfdc15432f07b0c4265dfc01a07f219462e4
-  data.tar.gz: 83d8be4487d3ac96349723c9c99ce113185a03a37cb6d18466b38b8e512eaef67d2c161340e61c7d9f53ab6075f1f069f8b7928a05818d4e7dd4d4e43f028f43
+  metadata.gz: 2b3af5bf281253d498ec03a219282d1b360337f036911e0eacfeb2cfcc0aaa7b0df0b8d69609191769f10e634937e403ca9af047c889e816ecb4837bd3a1e3e5
+  data.tar.gz: 2ccc75bf7e0791aa1e38834c2fa3f1900f9073ed889161caab8cb306d403dcfd4bba44ebb7748d752f9838e311c37506a310210ff62e43617e5eae25f7703e7c

data/lib/posthog/client.rb

@@ -57,6 +57,8 @@ module PostHog
     # @option opts [String] :host Fully qualified hostname of the PostHog server. Defaults to `https://us.i.posthog.com`.
     # @option opts [Integer] :max_queue_size Maximum number of calls to remain queued. Defaults to 10_000.
     # @option opts [Integer] :batch_size Maximum number of events to send in one async batch.
+    # @option opts [Numeric] :flush_interval_seconds Maximum seconds to wait for an async batch to fill before sending.
+    #   Defaults to 5.
     # @option opts [Boolean] :test_mode +true+ if messages should remain queued for testing. Defaults to +false+.
     # @option opts [Boolean] :sync_mode +true+ to send events synchronously on the calling thread. Useful in
     #   forking environments like Sidekiq and Resque. Defaults to +false+.
@@ -172,6 +174,7 @@ module PostHog
 
       while !@queue.empty? || @worker.is_requesting?
         ensure_worker_running
+        @worker.request_flush
         sleep(0.1)
       end
     end
@@ -972,6 +975,7 @@ module PostHog
 
       if queued
         ensure_worker_running
+        @worker.notify
         true
       else
         logger.warn(

data/lib/posthog/defaults.rb

@@ -32,6 +32,7 @@ module PostHog
     module MessageBatch
       MAX_BYTES = 512_000 # 500Kb
       MAX_SIZE = 100
+      FLUSH_INTERVAL_SECONDS = 5.0 # seconds
     end
 
     module BackoffPolicy

data/lib/posthog/noop_worker.rb

@@ -21,6 +21,16 @@ module PostHog
       false
     end
 
+    # @return [void]
+    def request_flush
+      # Does nothing
+    end
+
+    # @return [void]
+    def notify
+      # Does nothing
+    end
+
     # @return [void]
     def shutdown
       # Does nothing

data/lib/posthog/send_worker.rb

@@ -23,6 +23,7 @@ module PostHog
     # @param api_key [String] Project API key.
     # @param options [Hash] Worker options.
     # @option options [Integer] :batch_size How many items to send in a batch.
+    # @option options [Numeric] :flush_interval_seconds Maximum seconds to wait for a batch to fill before sending.
     # @option options [Proc] :on_error Callback invoked as `on_error.call(status, error)`.
     # @option options [String] :host PostHog API host URL.
     # @option options [Boolean] :skip_ssl_verification Disable SSL certificate verification.
@@ -32,44 +33,74 @@ module PostHog
       @api_key = api_key
       @on_error = options[:on_error] || proc { |status, error| }
       batch_size = options[:batch_size] || Defaults::MessageBatch::MAX_SIZE
+      flush_interval_seconds = options[:flush_interval_seconds] || Defaults::MessageBatch::FLUSH_INTERVAL_SECONDS
+      @flush_interval_seconds = flush_interval_seconds.to_f
       @batch = MessageBatch.new(batch_size)
       @lock = Mutex.new
-      @shutdown_mutex = Mutex.new
+      @state_lock = Mutex.new
+      @condition = ConditionVariable.new
+      @flush_requested = false
       @shutdown = false
-      @transport = Transport.new api_host: options[:host], skip_ssl_verification: options[:skip_ssl_verification]
+      @pid = Process.pid
+      @transport_options = { api_host: options[:host], skip_ssl_verification: options[:skip_ssl_verification] }
+      @transport = Transport.new(@transport_options)
     end
 
     # Continuously runs the loop to check for new events.
     #
     # @return [void]
     def run
+      ensure_current_process!
+
       until shutdown?
-        return if @queue.empty?
+        wait_for_work
+        break if shutdown?
+        next if @queue.empty?
 
-        @lock.synchronize do
-          consume_message_from_queue! until @batch.full? || @queue.empty?
-        end
+        build_batch
 
         begin
-          unless @batch.empty?
-            res = @transport.send @api_key, @batch
-            handle_error(res.status, res.error) unless res.status == 200
-          end
+          send_batch unless @batch.empty?
         ensure
           @lock.synchronize { @batch.clear }
+          clear_flush_request_if_idle
         end
       end
     ensure
-      # Worker threads exit when the queue is drained and are restarted for the
-      # next burst of events. Close the persistent connection on each exit and
-      # let Transport reconnect lazily when a future worker sends another batch.
-      @transport.shutdown
+      shutdown_transport
+    end
+
+    # Request the worker to send any pending events without waiting for the
+    # configured flush interval. Used by Client#flush and shutdown paths.
+    #
+    # @return [void]
+    def request_flush
+      ensure_current_process!
+
+      @state_lock.synchronize do
+        @flush_requested = true
+        @condition.broadcast
+      end
+    end
+
+    # Wake the worker when producers enqueue new messages.
+    #
+    # @return [void]
+    def notify
+      ensure_current_process!
+
+      @state_lock.synchronize { @condition.signal }
     end
 
     # @return [void]
     def shutdown
-      @shutdown_mutex.synchronize { @shutdown = true }
-      @transport.shutdown
+      ensure_current_process!
+
+      @state_lock.synchronize do
+        @shutdown = true
+        @flush_requested = true
+        @condition.broadcast
+      end
     end
 
     # public: Check whether we have outstanding requests.
@@ -77,25 +108,108 @@ module PostHog
     # @return [Boolean] Whether the worker has outstanding requests.
     # TODO: Rename to `requesting?` in future version
     def is_requesting? # rubocop:disable Naming/PredicateName
+      ensure_current_process!
+
       @lock.synchronize { !@batch.empty? }
     end
 
     private
 
-    def shutdown?
-      @shutdown_mutex.synchronize { @shutdown }
+    def ensure_current_process!
+      return if @pid == Process.pid
+
+      @lock.synchronize { @batch.clear }
+      @state_lock.synchronize do
+        @pid = Process.pid
+        @shutdown = false
+        @flush_requested = false
+        @condition.broadcast
+      end
+      shutdown_transport
+      @transport = Transport.new(@transport_options)
+    end
+
+    def build_batch
+      deadline = monotonic_time + @flush_interval_seconds
+
+      loop do
+        @lock.synchronize do
+          consume_message_from_queue! until @batch.full? || @queue.empty?
+        end
+
+        break if @batch.full? || @batch.empty? || flush_requested?
+
+        remaining = deadline - monotonic_time
+        break unless remaining.positive?
+
+        wait_for_more_messages(remaining)
+      end
+    end
+
+    def send_batch
+      res = @transport.send @api_key, @batch
+      handle_error(res.status, res.error) unless res.status == 200
     end
 
     def consume_message_from_queue!
-      @batch << @queue.pop
+      @batch << @queue.pop(true)
+    rescue ThreadError
+      # Queue was emptied by another thread between #empty? and #pop.
     rescue MessageBatch::JSONGenerationError => e
       handle_error(-1, e.to_s)
     end
 
+    def wait_for_work
+      @state_lock.synchronize do
+        while @queue.empty? && !@shutdown
+          clear_flush_request_without_lock
+          @condition.wait(@state_lock)
+        end
+      end
+    end
+
+    def wait_for_more_messages(timeout)
+      @state_lock.synchronize do
+        return if @flush_requested || @shutdown || !@queue.empty?
+
+        @condition.wait(@state_lock, timeout)
+      end
+    end
+
+    def flush_requested?
+      @state_lock.synchronize { @flush_requested }
+    end
+
+    def shutdown?
+      @state_lock.synchronize { @shutdown }
+    end
+
+    def clear_flush_request
+      @state_lock.synchronize { clear_flush_request_without_lock }
+    end
+
+    def clear_flush_request_if_idle
+      @state_lock.synchronize { clear_flush_request_without_lock if @queue.empty? }
+    end
+
+    def clear_flush_request_without_lock
+      @flush_requested = false
+    end
+
     def handle_error(status, error)
       @on_error.call(status, error)
     rescue StandardError => e
       logger.error("Error in on_error callback: #{e.message}")
     end
+
+    def shutdown_transport
+      @transport.shutdown
+    rescue StandardError => e
+      logger.error("Error shutting down transport: #{e.message}")
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
   end
 end

data/lib/posthog/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PostHog
-  VERSION = '3.13.1'
+  VERSION = '3.14.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: posthog-ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.1
+  version: 3.14.0
 platform: ruby
 authors:
 - ''