posthog-ruby 3.7.0 → 3.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afcf66d4afc793e15c83b53e455ef605218def4581460279d45721b82c1f73f2
-  data.tar.gz: 96f13bf72ddc840302d71c21072db26bdd098b73fd862455dc65b745357dc7d2
+  metadata.gz: 4400cef0c43dd5e79c18f38712b6f0033271f798ad8f97362338516ab491185a
+  data.tar.gz: c789f72bcd04df210a74e79d9069e20a5a7f02b0b9b48eae344f58a33c348c8e
 SHA512:
-  metadata.gz: 8b3e3871c5be034db9928b012cc0a3417121dc6f1ab4e7c5ece24e1c637dc04959ef50e4f551de598e11c4922d4f54048a9438bb03c86eb1e0eac67eabefdf7d
-  data.tar.gz: 3bf3128f6333b9678aa9c3a616494fcbff369ece30a0b0c422468cdab8856902a4184a560da84d6dbadb3dc935555b7402fe63d9158ea1da62589115247e7357
+  metadata.gz: fc6f2f8cfd188881c9aec1ab5867bf555ebfc8fdf12f87e2fb086884e75968e268df8346b1463a563bb48529f6f7c6326366718885c6e6584aa140ff5aa15f87
+  data.tar.gz: 7b6c516b339b0beaa8a0980d5e1d02027e826065f6bb28c85817344227cced2500b95e359bfe8955af952f553dc9b6cee958be8ffe2f52629d1bd1cf3df5e6f6

data/lib/posthog/client.rb

@@ -364,15 +364,15 @@ module PostHog
       !!response
     end
 
-    # @param [String] flag_key The unique flag key of the feature flag
+    # @param [String, Symbol] flag_key The unique flag key of the feature flag
     # @return [String] The decrypted value of the feature flag payload
     def get_remote_config_payload(flag_key)
-      @feature_flags_poller.get_remote_config_payload(flag_key)
+      @feature_flags_poller.get_remote_config_payload(flag_key.to_s)
     end
 
     # Returns whether the given feature flag is enabled for the given user or not
     #
-    # @param [String] key The key of the feature flag
+    # @param [String, Symbol] key The key of the feature flag
     # @param [String] distinct_id The distinct id of the user
     # @param [Hash] groups
     # @param [Hash] person_properties key-value pairs of properties to associate with the user.
@@ -455,7 +455,7 @@ module PostHog
     # @param [Hash] group_properties
     # @param [Boolean] only_evaluate_locally Skip the remote /flags call entirely
     # @param [Boolean] disable_geoip Stamped on captured access events
-    # @param [Array<String>] flag_keys When set, scopes the underlying /flags
+    # @param [Array<String, Symbol>] flag_keys When set, scopes the underlying /flags
     #   request to only these flag keys (sent as `flag_keys_to_evaluate`).
     #   Distinct from {FeatureFlagEvaluations#only}, which filters the
     #   already-fetched snapshot in memory.
@@ -598,7 +598,7 @@ module PostHog
     # @deprecated Use {#get_feature_flag_result} instead, which returns both the flag value and payload
     #   and properly raises the $feature_flag_called event.
     #
-    # @param [String] key The key of the feature flag
+    # @param [String, Symbol] key The key of the feature flag
     # @param [String] distinct_id The distinct id of the user
     # @option [String or boolean] match_value The value of the feature flag to be matched
     # @option [Hash] groups
@@ -623,6 +623,7 @@ module PostHog
         'instead — this consolidates flag evaluation into a single `/flags` request per ' \
         'incoming request.'
       )
+      key = key.to_s
       person_properties, group_properties = add_local_person_and_group_properties(distinct_id, groups,
                                                                                   person_properties, group_properties)
       @feature_flags_poller.get_feature_flag_payload(key, distinct_id, match_value, groups, person_properties,
@@ -725,6 +726,7 @@ module PostHog
       only_evaluate_locally: false,
       send_feature_flag_events: true
     )
+      key = key.to_s
       person_properties, group_properties = add_local_person_and_group_properties(
         distinct_id, groups, person_properties, group_properties
       )

data/lib/posthog/feature_flags.rb

@@ -125,6 +125,7 @@ module PostHog
 
     def get_flags(distinct_id, groups = {}, person_properties = {}, group_properties = {}, flag_keys = nil,
                   disable_geoip = nil)
+      flag_keys = flag_keys.map(&:to_s) if flag_keys.is_a?(Array)
       request_data = {
         distinct_id: distinct_id,
         groups: groups,
@@ -160,7 +161,7 @@ module PostHog
     end
 
     def get_remote_config_payload(flag_key)
-      _request_remote_config_payload(flag_key)
+      _request_remote_config_payload(flag_key.to_s)
     end
 
     def get_feature_flag(
@@ -171,6 +172,8 @@ module PostHog
       group_properties = {},
       only_evaluate_locally = false
     )
+      key = key.to_s
+
       # make sure they're loaded on first run
       load_feature_flags
 
@@ -363,6 +366,8 @@ module PostHog
       group_properties = {},
       only_evaluate_locally = false
     )
+      key = key.to_s
+
       if match_value.nil?
         match_value = get_feature_flag(
           key,
@@ -892,7 +897,8 @@ module PostHog
 
       aggregation_group_type_index = flag_filters[:aggregation_group_type_index]
       if aggregation_group_type_index.nil?
-        return match_feature_flag_properties(flag, distinct_id, person_properties, evaluation_cache, @cohorts)
+        return match_feature_flag_properties(flag, distinct_id, person_properties, evaluation_cache, @cohorts,
+                                             groups: groups, group_properties: group_properties)
       end
 
       group_name = @group_type_mapping[aggregation_group_type_index.to_s.to_sym]
@@ -916,12 +922,13 @@ module PostHog
 
       focused_group_properties = group_properties[group_name_symbol]
       match_feature_flag_properties(flag, groups[group_name_symbol], focused_group_properties, evaluation_cache,
-                                    @cohorts)
+                                    @cohorts, groups: groups, group_properties: group_properties)
     end
 
     def _compute_flag_payload_locally(key, match_value)
       return nil if @feature_flags_by_key.nil?
 
+      key = key.to_s
       response = nil
       if [true, false].include? match_value
         response = @feature_flags_by_key.dig(key, :filters, :payloads, match_value.to_s.to_sym)
@@ -931,23 +938,57 @@ module PostHog
       response
     end
 
-    def match_feature_flag_properties(flag, distinct_id, properties, evaluation_cache, cohort_properties = {})
+    def match_feature_flag_properties(flag, distinct_id, properties, evaluation_cache, cohort_properties = {},
+                                      groups: {}, group_properties: {})
       flag_filters = flag[:filters] || {}
 
       flag_conditions = flag_filters[:groups] || []
+      flag_aggregation = flag_filters[:aggregation_group_type_index]
       is_inconclusive = false
       result = nil
 
       # NOTE: This NEEDS to be `each` because `each_key` breaks
       flag_conditions.each do |condition|
-        if condition_match(flag, distinct_id, condition, properties, evaluation_cache, cohort_properties)
+        # Per-condition aggregation overrides only when the condition explicitly
+        # sets its own aggregation_group_type_index (mixed targeting). When absent,
+        # use the properties/bucketing already resolved by the caller.
+        condition_aggregation = condition.fetch(:aggregation_group_type_index, flag_aggregation)
+
+        effective_properties = properties
+        effective_bucketing = distinct_id
+
+        # Mixed-override path: condition-level aggregation differs from flag-level.
+        # This assumes flag-level aggregation is nil for mixed flags.
+        if condition_aggregation != flag_aggregation
+          if condition_aggregation.nil?
+            # Person condition under a mixed flag — caller already passed person props/bucketing.
+          else
+            group_name = @group_type_mapping[condition_aggregation.to_s.to_sym]
+            if group_name.nil? || !groups.key?(group_name.to_sym)
+              logger.debug do
+                "[FEATURE FLAGS] Skipping group condition for flag '#{flag[:key]}': " \
+                  "group type index #{condition_aggregation} not available"
+              end
+              next
+            end
+            unless group_properties.key?(group_name.to_sym)
+              is_inconclusive = true
+              next
+            end
+            effective_properties = group_properties[group_name.to_sym]
+            effective_bucketing = groups[group_name.to_sym]
+          end
+        end
+
+        if condition_match(flag, effective_bucketing, condition, effective_properties, evaluation_cache,
+                           cohort_properties)
           variant_override = condition[:variant]
           flag_multivariate = flag_filters[:multivariate] || {}
           flag_variants = flag_multivariate[:variants] || []
           variant = if flag_variants.map { |variant| variant[:key] }.include?(condition[:variant])
                       variant_override
                     else
-                      get_matching_variant(flag, distinct_id)
+                      get_matching_variant(flag, effective_bucketing)
                     end
           result = variant || true
           break

data/lib/posthog/version.rb

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

metadata

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