posthog-ruby 3.15.0 → 3.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab01f90a9fbe05af027e92831b58e906eb38b30914230fd83a35cab28da40fcd
-  data.tar.gz: cf06c8facfe324712e096cedfeeef90c755705bcce79384cda2d7b5f4d675cf0
+  metadata.gz: 87c4c21f1799cc12f7e4792f728194091a4e3abfe28fa26315469c43cbefd6ba
+  data.tar.gz: 4fa4b2455dcf53c3e805616af1e5eb5ae266729f90832f4c4491147c6626f71d
 SHA512:
-  metadata.gz: 6825662770b6a96fce094e2c46619fe142144ef8098db49c6a67b4f1faf54d731b65c8767f985413c91bf097767db84648fe2b2ba938ca4f788a0201ffa6002e
-  data.tar.gz: 8501399ef589da90e3e7c65629df24d99012240c718874a506fede7833225316a1c97881a8eca1df06a831eace6e9090e3b052686c7656c8cd9a3a1815e3a6b7
+  metadata.gz: b1fce8fb104ff14b8564649222d729fdd6feda8d3382119eee8c034663108edb972932aaee7d17de6d87911816986e55236a554ce19ba107e032bc04f4fdab7d
+  data.tar.gz: b95fecee03f14f695410f76230e8e1284286c4835cd8f4c2ef66779fc57a27bda7e7c3e892a989207ebd85d1f9531a6034a041dade066d776707ae03c7227661

data/lib/posthog/backoff_policy.rb

@@ -33,7 +33,7 @@ module PostHog
 
       @attempts += 1
 
-      [interval, @max_timeout_ms].min
+      interval.clamp(@min_timeout_ms, @max_timeout_ms)
     end
 
     private

data/lib/posthog/client.rb

@@ -67,6 +67,8 @@ 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] :max_retries How many times to retry batch uploads after the first send attempt.
+    #   Defaults to the transport default. Set to 0 to disable retrying.
     # @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.
@@ -110,7 +112,7 @@ module PostHog
         @transport = Transport.new(
           api_host: opts[:host],
           skip_ssl_verification: opts[:skip_ssl_verification],
-          retries: 3,
+          retries: opts.key?(:max_retries) ? opts[:max_retries].to_i + 1 : 3,
           compress_request: opts[:compress_request]
         )
         @sync_lock = Mutex.new

data/lib/posthog/feature_flags.rb

@@ -36,8 +36,9 @@ 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.
+    # @param feature_flag_request_max_retries [Integer, nil] Retries after a transient network error or retryable
+    #   HTTP response status 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,
@@ -150,7 +151,7 @@ module PostHog
         group_properties: group_properties
       }
       request_data[:flag_keys_to_evaluate] = flag_keys if flag_keys && !flag_keys.empty?
-      request_data[:geoip_disable] = true if disable_geoip
+      request_data[:geoip_disable] = disable_geoip unless disable_geoip.nil?
 
       flags_response = _request_feature_flag_evaluation(request_data)
 
@@ -1234,7 +1235,12 @@ module PostHog
       data['token'] = @project_api_key
       req.body = data.to_json
 
-      _request(uri, req, @feature_flag_request_timeout_seconds)
+      _request(
+        uri,
+        req,
+        @feature_flag_request_timeout_seconds,
+        retry_status_codes: RETRYABLE_FLAGS_REQUEST_STATUS_CODES
+      )
     end
 
     def _request_remote_config_payload(flag_key)
@@ -1256,14 +1262,15 @@ module PostHog
       Errno::ECONNRESET,
       EOFError
     ].freeze
+    RETRYABLE_FLAGS_REQUEST_STATUS_CODES = [502, 504].freeze
 
-    def _request(uri, request_object, timeout = nil, include_etag: false)
+    def _request(uri, request_object, timeout = nil, include_etag: false, retry_status_codes: [])
       request_object['User-Agent'] = "posthog-ruby/#{PostHog::VERSION}"
       request_timeout = timeout || 10
       backoff_policy = nil
       attempts = 0
 
-      begin
+      loop do
         attempts += 1
         Net::HTTP.start(
           uri.hostname,
@@ -1277,6 +1284,16 @@ module PostHog
           status_code = res.code.to_i
           etag = include_etag ? res['ETag'] : nil
 
+          if retry_status_codes.include?(status_code) && 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 HTTP #{status_code} (attempt #{attempts})"
+            )
+            sleep(interval)
+            next
+          end
+
           # Handle 304 Not Modified - return special response indicating no change
           if status_code == 304
             logger.debug("#{request_object.method} #{_mask_tokens_in_url(uri.to_s)} returned 304 Not Modified")
@@ -1304,7 +1321,7 @@ module PostHog
           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
+          next
         end
         logger.debug("Unable to complete request to #{_mask_tokens_in_url(uri.to_s)}")
         raise

data/lib/posthog/send_worker.rb

@@ -48,6 +48,7 @@ module PostHog
         skip_ssl_verification: options[:skip_ssl_verification],
         compress_request: options[:compress_request]
       }
+      @transport_options[:retries] = options[:max_retries].to_i + 1 if options.key?(:max_retries)
       @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 'time'
 require 'zlib'
 
 module PostHog
@@ -42,11 +43,12 @@ module PostHog
       options[:port] = options[:port].nil? ? PORT : options[:port]
       options[:ssl] = options[:ssl].nil? ? SSL : options[:ssl]
 
-      @headers = options[:headers] || HEADERS
+      @headers = (options[:headers] || HEADERS).dup
       @path = options[:path] || PATH
       @retries = options[:retries] || RETRIES
       @backoff_policy = options[:backoff_policy] || PostHog::BackoffPolicy.new
       @compress_request = options[:compress_request] != false
+      @last_retry_after = nil
 
       http = Net::HTTP.new(options[:host], options[:port])
       http.use_ssl = options[:ssl]
@@ -103,10 +105,8 @@ module PostHog
     private
 
     def should_retry_request?(status_code, body)
-      if status_code >= 500
-        true # Server error
-      elsif status_code == 429 # rubocop:disable Lint/DuplicateBranch
-        true # Rate limited
+      if status_code >= 500 || [408, 429].include?(status_code)
+        true # Server error, request timeout, or rate limited
       elsif status_code >= 400
         logger.error(body)
         false # Client error. Do not retry, but log
@@ -136,15 +136,37 @@ module PostHog
 
       if should_retry && (retries_remaining > 1)
         logger.debug("Retrying request, #{retries_remaining} retries left")
-        sleep(@backoff_policy.next_interval.to_f / 1000)
+        sleep(retry_delay_seconds)
         retry_with_backoff(retries_remaining - 1, &block)
       else
         [result, caught_exception]
       end
     end
 
+    def retry_delay_seconds
+      retry_after = parse_retry_after(@last_retry_after)
+      @last_retry_after = nil
+      return retry_after if retry_after
+
+      @backoff_policy.next_interval.to_f / 1000
+    end
+
+    def parse_retry_after(value)
+      return nil if value.nil? || value.empty?
+
+      seconds = Float(value, exception: false)
+      return seconds if seconds && seconds >= 0
+
+      parsed_time = Time.httpdate(value)
+      delay = parsed_time - Time.now
+      delay.positive? ? delay : nil
+    rescue ArgumentError
+      nil
+    end
+
     # Sends a request for the batch, returns [status_code, body]
     def send_request(api_key, batch)
+      @last_retry_after = nil
       payload = JSON.generate(api_key: api_key, batch: batch)
 
       request_path, request_headers, request_payload = build_request(@path, @headers, payload)
@@ -159,6 +181,7 @@ module PostHog
         @http_mutex.synchronize do
           @http.start unless @http.started? # Maintain a persistent connection
           response = @http.request(request, request_payload)
+          @last_retry_after = response['Retry-After']
           [response.code.to_i, response.body]
         end
       end

data/lib/posthog/version.rb

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

metadata

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