posthog-ruby 3.14.2 → 3.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a92261df7b02c5a549f4969422323c5d2c911ec16990fdb4861acc2ca76c3f3
-  data.tar.gz: bb5d161962343c95e628ddeb5e5bf053ad2d3c74737dbb4ae347e5a37077c82c
+  metadata.gz: ab01f90a9fbe05af027e92831b58e906eb38b30914230fd83a35cab28da40fcd
+  data.tar.gz: cf06c8facfe324712e096cedfeeef90c755705bcce79384cda2d7b5f4d675cf0
 SHA512:
-  metadata.gz: 2c8a69d40d6dda952c2a3ef0d2b1def8ac9c2e6f8acf87e53aae5b62ca9f538628a87c1451475034917f8a003f2f7b901cbd8c41c16c5b2c0d17381a62bdc192
-  data.tar.gz: a5be03ab5250513092e907238fe0ffcdcf8cdf6124a8cc20cd4eeabdd0123b8e7db9c88c0bf40d861eccfc10f551f0871ba29b075cbaf32172003d8cf4e9f9d6
+  metadata.gz: 6825662770b6a96fce094e2c46619fe142144ef8098db49c6a67b4f1faf54d731b65c8767f985413c91bf097767db84648fe2b2ba938ca4f788a0201ffa6002e
+  data.tar.gz: 8501399ef589da90e3e7c65629df24d99012240c718874a506fede7833225316a1c97881a8eca1df06a831eace6e9090e3b052686c7656c8cd9a3a1815e3a6b7

data/lib/posthog/client.rb

@@ -67,12 +67,16 @@ module PostHog
     #   in seconds. Defaults to 30.
     # @option opts [Integer] :feature_flag_request_timeout_seconds How long to wait for feature flag evaluation,
     #   in seconds. Defaults to 3.
+    # @option opts [Integer] :feature_flag_request_max_retries How many times to retry a flag request after a
+    #   transient network error. Each retry sleeps on the calling thread before retrying, so this adds to
+    #   worst-case latency. Defaults to 1. Set to 0 to disable retrying.
     # @option opts [Proc] :before_send A callback that receives the event hash and should return either a modified
     #   hash to be sent to PostHog or nil to prevent the event from being sent. e.g. `before_send: ->(event) { event }`.
     # @option opts [Boolean] :disable_singleton_warning +true+ to suppress the warning when multiple clients share
     #   the same API key. Use only when you intentionally need multiple clients. Defaults to +false+.
     # @option opts [Boolean] :skip_ssl_verification +true+ to disable SSL certificate verification for requests.
     #   Intended only for local development or custom deployments.
+    # @option opts [Boolean] :compress_request Set to +false+ to disable gzip compression for batch uploads.
     # @option opts [Object] :flag_definition_cache_provider An object implementing the {FlagDefinitionCacheProvider}
     #   interface for distributed flag definition caching.
     # @option opts [Boolean] :is_server +true+ to stamp captured events with `$is_server => true` so PostHog
@@ -106,7 +110,8 @@ module PostHog
         @transport = Transport.new(
           api_host: opts[:host],
           skip_ssl_verification: opts[:skip_ssl_verification],
-          retries: 3
+          retries: 3,
+          compress_request: opts[:compress_request]
         )
         @sync_lock = Mutex.new
       end
@@ -140,7 +145,8 @@ module PostHog
             opts[:host],
             opts[:feature_flag_request_timeout_seconds] || Defaults::FeatureFlags::FLAG_REQUEST_TIMEOUT_SECONDS,
             opts[:on_error],
-            flag_definition_cache_provider: opts[:flag_definition_cache_provider]
+            flag_definition_cache_provider: opts[:flag_definition_cache_provider],
+            feature_flag_request_max_retries: opts[:feature_flag_request_max_retries]
           )
       end
 

data/lib/posthog/defaults.rb

@@ -19,6 +19,10 @@ module PostHog
 
     module FeatureFlags
       FLAG_REQUEST_TIMEOUT_SECONDS = 3
+      # Number of retries for a flag request after a transient network error.
+      # Flag requests are stateless and cause no server-side mutation, so
+      # retrying is safe.
+      FLAG_REQUEST_MAX_RETRIES = 1
     end
 
     module Queue

data/lib/posthog/feature_flags.rb

@@ -5,6 +5,8 @@ require 'net/http'
 require 'json'
 require 'posthog/version'
 require 'posthog/logging'
+require 'posthog/defaults'
+require 'posthog/backoff_policy'
 require 'posthog/feature_flag'
 require 'posthog/flag_definition_cache'
 require 'digest'
@@ -34,6 +36,8 @@ module PostHog
     # @param feature_flag_request_timeout_seconds [Integer] Timeout for feature flag requests.
     # @param on_error [Proc, nil] Callback invoked as `on_error.call(status, error)`.
     # @param flag_definition_cache_provider [Object, nil] Optional {FlagDefinitionCacheProvider} implementation.
+    # @param feature_flag_request_max_retries [Integer, nil] Retries after a transient network error on a flag
+    #   request. Defaults to {Defaults::FeatureFlags::FLAG_REQUEST_MAX_RETRIES}. Set to 0 to disable retrying.
     def initialize(
       polling_interval,
       personal_api_key,
@@ -41,7 +45,8 @@ module PostHog
       host,
       feature_flag_request_timeout_seconds,
       on_error = nil,
-      flag_definition_cache_provider: nil
+      flag_definition_cache_provider: nil,
+      feature_flag_request_max_retries: nil
     )
       @polling_interval = polling_interval || 30
       @personal_api_key = personal_api_key
@@ -53,6 +58,8 @@ module PostHog
       @loaded_flags_successfully_once = Concurrent::AtomicBoolean.new
       @feature_flags_by_key = nil
       @feature_flag_request_timeout_seconds = feature_flag_request_timeout_seconds
+      @feature_flag_request_max_retries =
+        feature_flag_request_max_retries || Defaults::FeatureFlags::FLAG_REQUEST_MAX_RETRIES
       @on_error = on_error || proc { |status, error| }
       @quota_limited = Concurrent::AtomicBoolean.new(false)
       @flags_etag = Concurrent::AtomicReference.new(nil)
@@ -1240,12 +1247,24 @@ module PostHog
       _request(uri, req, @feature_flag_request_timeout_seconds)
     end
 
-    # rubocop:disable Lint/ShadowedException
+    # Transient network errors that are safe to retry. Flag requests are
+    # retry-safe (stateless reads and evaluations, no server-side mutation), so
+    # a one-off blip (TCP retransmit, TLS jitter, an edge/proxy hiccup) should
+    # be absorbed by a retry rather than surfaced to the caller.
+    RETRYABLE_REQUEST_ERRORS = [
+      Timeout::Error, # covers Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout
+      Errno::ECONNRESET,
+      EOFError
+    ].freeze
+
     def _request(uri, request_object, timeout = nil, include_etag: false)
       request_object['User-Agent'] = "posthog-ruby/#{PostHog::VERSION}"
       request_timeout = timeout || 10
+      backoff_policy = nil
+      attempts = 0
 
       begin
+        attempts += 1
         Net::HTTP.start(
           uri.hostname,
           uri.port,
@@ -1279,20 +1298,24 @@ module PostHog
             return error_response
           end
         end
-      rescue Timeout::Error,
-             Errno::EINVAL,
-             Errno::ECONNRESET,
-             EOFError,
+      rescue *RETRYABLE_REQUEST_ERRORS => e
+        if attempts <= @feature_flag_request_max_retries
+          backoff_policy ||= BackoffPolicy.new
+          interval = backoff_policy.next_interval.to_f / 1000
+          logger.debug("Retrying request to #{_mask_tokens_in_url(uri.to_s)} after #{e.class} (attempt #{attempts})")
+          sleep(interval)
+          retry
+        end
+        logger.debug("Unable to complete request to #{_mask_tokens_in_url(uri.to_s)}")
+        raise
+      rescue Errno::EINVAL,
              Net::HTTPBadResponse,
              Net::HTTPHeaderSyntaxError,
-             Net::ReadTimeout,
-             Net::WriteTimeout,
              Net::ProtocolError
-        logger.debug("Unable to complete request to #{uri}")
+        logger.debug("Unable to complete request to #{_mask_tokens_in_url(uri.to_s)}")
         raise
       end
     end
-    # rubocop:enable Lint/ShadowedException
 
     def _mask_tokens_in_url(url)
       url.gsub(/token=([^&]{10})[^&]*/, 'token=\1...')

data/lib/posthog/send_worker.rb

@@ -27,6 +27,7 @@ module PostHog
     # @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.
+    # @option options [Boolean] :compress_request Set to +false+ to disable gzip batch request bodies.
     def initialize(queue, api_key, options = {})
       symbolize_keys! options
       @queue = queue
@@ -42,7 +43,11 @@ module PostHog
       @flush_requested = false
       @shutdown = false
       @pid = Process.pid
-      @transport_options = { api_host: options[:host], skip_ssl_verification: options[:skip_ssl_verification] }
+      @transport_options = {
+        api_host: options[:host],
+        skip_ssl_verification: options[:skip_ssl_verification],
+        compress_request: options[:compress_request]
+      }
       @transport = Transport.new(@transport_options)
     end
 

data/lib/posthog/transport.rb

@@ -8,6 +8,7 @@ require 'posthog/backoff_policy'
 require 'net/http'
 require 'net/https'
 require 'json'
+require 'zlib'
 
 module PostHog
   # HTTP transport used by the SDK workers.
@@ -28,6 +29,7 @@ module PostHog
     # @option options [Integer] :retries Number of retry attempts for retryable failures.
     # @option options [PostHog::BackoffPolicy] :backoff_policy Backoff policy used between retries.
     # @option options [Boolean] :skip_ssl_verification Disable SSL certificate verification.
+    # @option options [Boolean] :compress_request Whether to gzip batch request bodies. Defaults to +true+.
     def initialize(options = {})
       if options[:api_host]
         uri = URI.parse(options[:api_host])
@@ -44,6 +46,7 @@ module PostHog
       @path = options[:path] || PATH
       @retries = options[:retries] || RETRIES
       @backoff_policy = options[:backoff_policy] || PostHog::BackoffPolicy.new
+      @compress_request = options[:compress_request] != false
 
       http = Net::HTTP.new(options[:host], options[:port])
       http.use_ssl = options[:ssl]
@@ -144,22 +147,41 @@ module PostHog
     def send_request(api_key, batch)
       payload = JSON.generate(api_key: api_key, batch: batch)
 
-      request = Net::HTTP::Post.new(@path, @headers)
+      request_path, request_headers, request_payload = build_request(@path, @headers, payload)
+      request = Net::HTTP::Post.new(request_path, request_headers)
 
       if self.class.stub
-        logger.debug "stubbed request to #{@path}: " \
+        logger.debug "stubbed request to #{request_path}: " \
                      "api key = #{api_key}, batch = #{JSON.generate(batch)}"
 
         [200, '{}']
       else
         @http_mutex.synchronize do
           @http.start unless @http.started? # Maintain a persistent connection
-          response = @http.request(request, payload)
+          response = @http.request(request, request_payload)
           [response.code.to_i, response.body]
         end
       end
     end
 
+    def build_request(path, headers, payload)
+      return [path, headers, payload] unless @compress_request
+
+      compressed_payload = gzip_payload(payload)
+      return [path, headers, payload] unless compressed_payload
+
+      compressed_headers = headers.merge('Content-Encoding' => 'gzip')
+
+      [path, compressed_headers, compressed_payload]
+    end
+
+    def gzip_payload(payload)
+      Zlib.gzip(payload)
+    rescue Zlib::Error => e
+      logger.warn("gzip compression failed; sending uncompressed - #{e.message}")
+      nil
+    end
+
     class << self
       attr_writer :stub
 

data/lib/posthog/version.rb

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

metadata

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