posthog-ruby 3.1.1 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47b1ce0c330a250b307dd757fa3024fcd516e8cf264576e52fde101c412d2e76
-  data.tar.gz: '08725cd78aab55aa87b70ebcf65a2a061b641cbab043a2df61552eff199cc534'
+  metadata.gz: 73269e57e35a55b2ff07748aa4cab6da17c37b42d64a170528cb5dd1955a9365
+  data.tar.gz: 831672593c8646bb05fae81c527a0e64016d3fbae42e722a6525988ce3257b73
 SHA512:
-  metadata.gz: 983808c3419cfab8772b3dbe175070d42dc10a357f1cb657bc36aa56389e867027e4c3ad3286d2d78eb2c232e2448f7190658beafcb846d2e5f72deb3d747d04
-  data.tar.gz: 92aab3899eb59d728170098b0b6ff62badffbcc890080c67eaf9657399f3de4f3c96d6241942ec1bf64b06bdc53e9dd588845a4c4cbe8b079759cbe51a71b0df
+  metadata.gz: 6805d61de4837441d2b4a333f76e093cac6668e2cbf9dba88fa1602f02ce7fedd28ab5cf433217bc1d40127bcf73e2f7ccebeaeb8086a98ec45a5c26b139b030
+  data.tar.gz: ec9ad7127fe2d0b6d78e1c6f9f28e4ccaf3c99362edc8f20e1b8f06afe56cbc84538bc9bcbc4acbce4d81a546e6046acddfb1cc0ac5ba5cba5f52b04446d467b

data/bin/fmt

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+#/ Usage: bin/fmt [--check]
+#/ Description: Format code using rubocop. Use --check to only check formatting without fixing.
+source bin/helpers/_utils.sh
+set_source_and_root_dir
+
+# Check if --check flag is provided
+if [[ "$1" == "--check" ]]; then
+    echo "Checking code formatting..."
+    rubocop
+else
+    echo "Formatting code with rubocop..."
+    rubocop --autocorrect-all
+fi

data/bin/test

@@ -4,4 +4,6 @@
 source bin/helpers/_utils.sh
 set_source_and_root_dir
 
-bundle exec rspec
+# Use RUBYLIB to avoid bundler dependency issues
+# This allows tests to run even if bundler can't resolve all dev dependencies
+RUBYLIB=lib rspec "$@"

data/lib/posthog/feature_flags.rb

@@ -30,6 +30,7 @@ module PostHog
       @host = host
       @feature_flags = Concurrent::Array.new
       @group_type_mapping = Concurrent::Hash.new
+      @cohorts = Concurrent::Hash.new
       @loaded_flags_successfully_once = Concurrent::AtomicBoolean.new
       @feature_flags_by_key = nil
       @feature_flag_request_timeout_seconds = feature_flag_request_timeout_seconds
@@ -367,13 +368,16 @@ module PostHog
       parsed_dt
     end
 
-    def self.match_property(property, property_values)
+    def self.match_property(property, property_values, cohort_properties = {})
       # only looks for matches where key exists in property_values
       # doesn't support operator is_not_set
 
       PostHog::Utils.symbolize_keys! property
       PostHog::Utils.symbolize_keys! property_values
 
+      # Handle cohort properties
+      return match_cohort(property, property_values, cohort_properties) if extract_value(property, :type) == 'cohort'
+
       key = property[:key].to_sym
       value = property[:value]
       operator = property[:operator] || 'exact'
@@ -443,7 +447,127 @@ module PostHog
       end
     end
 
-    private
+    def self.match_cohort(property, property_values, cohort_properties)
+      # Cohort properties are in the form of property groups like this:
+      # {
+      #   "cohort_id" => {
+      #     "type" => "AND|OR",
+      #     "values" => [{
+      #        "key" => "property_name", "value" => "property_value"
+      #     }]
+      #   }
+      # }
+      cohort_id = extract_value(property, :value).to_s
+      property_group = find_cohort_property(cohort_properties, cohort_id)
+
+      raise InconclusiveMatchError, "can't match cohort without a given cohort property value" unless property_group
+
+      match_property_group(property_group, property_values, cohort_properties)
+    end
+
+    def self.match_property_group(property_group, property_values, cohort_properties)
+      return true if property_group.nil? || property_group.empty?
+
+      group_type = extract_value(property_group, :type)
+      properties = extract_value(property_group, :values)
+
+      return true if properties.nil? || properties.empty?
+
+      if nested_property_group?(properties)
+        match_nested_property_group(properties, group_type, property_values, cohort_properties)
+      else
+        match_regular_property_group(properties, group_type, property_values, cohort_properties)
+      end
+    end
+
+    def self.extract_value(hash, key)
+      return nil unless hash.is_a?(Hash)
+
+      hash[key] || hash[key.to_s]
+    end
+
+    def self.find_cohort_property(cohort_properties, cohort_id)
+      return nil unless cohort_properties.is_a?(Hash)
+
+      cohort_properties[cohort_id] || cohort_properties[cohort_id.to_sym]
+    end
+
+    def self.nested_property_group?(properties)
+      return false unless properties&.any?
+
+      first_property = properties[0]
+      return false unless first_property.is_a?(Hash)
+
+      first_property.key?(:values) || first_property.key?('values')
+    end
+
+    def self.match_nested_property_group(properties, group_type, property_values, cohort_properties)
+      case group_type
+      when 'AND'
+        properties.each do |property|
+          return false unless match_property_group(property, property_values, cohort_properties)
+        end
+        true
+      when 'OR'
+        properties.each do |property|
+          return true if match_property_group(property, property_values, cohort_properties)
+        end
+        false
+      else
+        raise InconclusiveMatchError, "Unknown property group type: #{group_type}"
+      end
+    end
+
+    def self.match_regular_property_group(properties, group_type, property_values, cohort_properties)
+      # Validate group type upfront
+      raise InconclusiveMatchError, "Unknown property group type: #{group_type}" unless %w[AND OR].include?(group_type)
+
+      error_matching_locally = false
+
+      properties.each do |prop|
+        PostHog::Utils.symbolize_keys!(prop)
+        matches = evaluate_property_match(prop, property_values, cohort_properties)
+        next if matches.nil? # Skip flag dependencies
+
+        negated = prop[:negation] || false
+        final_result = negated ? !matches : matches
+
+        # Short-circuit based on group type
+        if group_type == 'AND'
+          return false unless final_result
+        elsif final_result # group_type == 'OR'
+          return true
+        end
+      rescue InconclusiveMatchError => e
+        PostHog::Logging.logger&.debug("Failed to compute property #{prop} locally: #{e}")
+        error_matching_locally = true
+      end
+
+      raise InconclusiveMatchError, "can't match cohort without a given cohort property value" if error_matching_locally
+
+      # If we reach here, return default based on group type
+      group_type == 'AND'
+    end
+
+    def self.evaluate_property_match(prop, property_values, cohort_properties)
+      prop_type = extract_value(prop, :type)
+
+      case prop_type
+      when 'cohort'
+        match_cohort(prop, property_values, cohort_properties)
+      when 'flag'
+        PostHog::Logging.logger&.warn(
+          '[FEATURE FLAGS] Flag dependency filters are not supported in local evaluation. ' \
+          "Skipping condition with dependency on flag '#{prop[:key]}'"
+        )
+        nil # Signal to skip this property
+      else
+        match_property(prop, property_values, cohort_properties)
+      end
+    end
+
+    private_class_method :extract_value, :find_cohort_property, :nested_property_group?,
+                         :match_nested_property_group, :match_regular_property_group, :evaluate_property_match
 
     def _compute_flag_locally(flag, distinct_id, groups = {}, person_properties = {}, group_properties = {})
       raise InconclusiveMatchError, 'Flag has experience continuity enabled' if flag[:ensure_experience_continuity]
@@ -453,7 +577,10 @@ module PostHog
       flag_filters = flag[:filters] || {}
 
       aggregation_group_type_index = flag_filters[:aggregation_group_type_index]
-      return match_feature_flag_properties(flag, distinct_id, person_properties) if aggregation_group_type_index.nil?
+      if aggregation_group_type_index.nil?
+        return match_feature_flag_properties(flag, distinct_id, person_properties,
+                                             @cohorts)
+      end
 
       group_name = @group_type_mapping[aggregation_group_type_index.to_s.to_sym]
 
@@ -475,7 +602,7 @@ module PostHog
       end
 
       focused_group_properties = group_properties[group_name_symbol]
-      match_feature_flag_properties(flag, groups[group_name_symbol], focused_group_properties)
+      match_feature_flag_properties(flag, groups[group_name_symbol], focused_group_properties, @cohorts)
     end
 
     def _compute_flag_payload_locally(key, match_value)
@@ -490,7 +617,7 @@ module PostHog
       response
     end
 
-    def match_feature_flag_properties(flag, distinct_id, properties)
+    def match_feature_flag_properties(flag, distinct_id, properties, cohort_properties = {})
       flag_filters = flag[:filters] || {}
 
       flag_conditions = flag_filters[:groups] || []
@@ -506,7 +633,7 @@ module PostHog
       # NOTE: This NEEDS to be `each` because `each_key` breaks
       # This is not a hash, it's just an array with 2 entries
       sorted_flag_conditions.each do |condition, _idx| # rubocop:disable Style/HashEachMethods
-        if is_condition_match(flag, distinct_id, condition, properties)
+        if is_condition_match(flag, distinct_id, condition, properties, cohort_properties)
           variant_override = condition[:variant]
           flag_multivariate = flag_filters[:multivariate] || {}
           flag_variants = flag_multivariate[:variants] || []
@@ -533,7 +660,7 @@ module PostHog
     end
 
     # TODO: Rename to `condition_match?` in future version
-    def is_condition_match(flag, distinct_id, condition, properties) # rubocop:disable Naming/PredicateName
+    def is_condition_match(flag, distinct_id, condition, properties, cohort_properties = {}) # rubocop:disable Naming/PredicateName
       rollout_percentage = condition[:rollout_percentage]
 
       unless (condition[:properties] || []).empty?
@@ -546,7 +673,7 @@ module PostHog
             )
             next true
           end
-          FeatureFlagsPoller.match_property(prop, properties)
+          FeatureFlagsPoller.match_property(prop, properties, cohort_properties)
         end
           return false
         elsif rollout_percentage.nil?
@@ -607,6 +734,7 @@ module PostHog
         @feature_flags = Concurrent::Array.new
         @feature_flags_by_key = {}
         @group_type_mapping = Concurrent::Hash.new
+        @cohorts = Concurrent::Hash.new
         @loaded_flags_successfully_once.make_false
         @quota_limited.make_true
         return
@@ -619,8 +747,9 @@ module PostHog
           @feature_flags_by_key[flag[:key]] = flag unless flag[:key].nil?
         end
         @group_type_mapping = res[:group_type_mapping] || {}
+        @cohorts = res[:cohorts] || {}
 
-        logger.debug "Loaded #{@feature_flags.length} feature flags"
+        logger.debug "Loaded #{@feature_flags.length} feature flags and #{@cohorts.length} cohorts"
         @loaded_flags_successfully_once.make_true if @loaded_flags_successfully_once.false?
       else
         logger.debug "Failed to load feature flags: #{res}"
@@ -629,7 +758,7 @@ module PostHog
 
     def _request_feature_flag_definitions
       uri = URI("#{@host}/api/feature_flag/local_evaluation")
-      uri.query = URI.encode_www_form([['token', @project_api_key]])
+      uri.query = URI.encode_www_form([['token', @project_api_key], %w[send_cohorts true]])
       req = Net::HTTP::Get.new(uri)
       req['Authorization'] = "Bearer #{@personal_api_key}"
 

data/lib/posthog/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: posthog-ruby
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.2
 platform: ruby
 authors:
 - ''
 bindir: bin
 cert_chain: []
-date: 2025-08-07 00:00:00.000000000 Z
+date: 2025-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -30,6 +30,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/fmt
 - bin/helpers/_utils.sh
 - bin/posthog
 - bin/test