posthog-ruby 1.3.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cc2c1e12c53fc80013ff8d49d082d1d35ad625fa0db972e53afbc205f595664
-  data.tar.gz: f95c1cb5502e0ae2d58e10b0575065fb797bbccd73d96098249a50ab6f60ee0a
+  metadata.gz: ef38f429ce00bcdcfc5c861fd163c420b9b3823b7cbcef4019a8bad580a6ad6f
+  data.tar.gz: '08effac4bc47b38a6e67fe2f578cd67a974a7462dcaa6e73e92ac11b5bb34333'
 SHA512:
-  metadata.gz: 8947ba953b888db638dff4ee913fa697eb80d0ac4e8796a705143278bae9aef67d7d966cdb6112309e2a51b5432fe340676036f2756bcbef885f801c929de13d
-  data.tar.gz: c95c85e49f02acd99043120ccc6b7889b30553da9d968cdc08f7bfe13e130bd5f42380a68714c712f0444777a24bfcb29e252a28ce319f01242a362c9ca2e4e0
+  metadata.gz: 86892110210900d5a3faa13fe2c335ce7d1ce0390390ff25c3d8a29510187d8829bda4795ead866471aaab7fa333f50a9b8251ff8e4ae47411d7a601d9f15eb2
+  data.tar.gz: 80374572728723780c1930555491445a4761685df6574305c0de73f9d0fbd1630924c5fd4412b469f735bd44d7657b7160d73ccb4094c978b58bb7494950bb32

data/lib/posthog/client.rb

@@ -20,9 +20,13 @@ class PostHog
     # @option opts [Bool] :test_mode +true+ if messages should remain
     #   queued for testing. Defaults to +false+.
     # @option opts [Proc] :on_error Handles error calls from the API.
+    # @option opts [String] :host Fully qualified hostname of the PostHog server. Defaults to `https://app.posthog.com`
+    # @option opts [Integer] :feature_flags_polling_interval How often to poll for feature flag definition changes. Measured in seconds, defaults to 30.
     def initialize(opts = {})
       symbolize_keys!(opts)
 
+      opts[:host] ||= 'https://app.posthog.com'
+
       @queue = Queue.new
       @api_key = opts[:api_key]
       @max_queue_size = opts[:max_queue_size] || Defaults::Queue::MAX_SIZE
@@ -34,20 +38,19 @@ class PostHog
       end
       @worker_thread = nil
       @feature_flags_poller = nil
-      @personal_api_key = nil
+      @personal_api_key = opts[:personal_api_key]
 
       check_api_key!
 
-      if opts[:personal_api_key]
-        @personal_api_key = opts[:personal_api_key]
-        @feature_flags_poller =
-          FeatureFlagsPoller.new(
-            opts[:feature_flags_polling_interval],
-            opts[:personal_api_key],
-            @api_key,
-            opts[:host]
-          )
-      end
+      @feature_flags_poller =
+        FeatureFlagsPoller.new(
+          opts[:feature_flags_polling_interval],
+          opts[:personal_api_key],
+          @api_key,
+          opts[:host]
+        )
+      
+      @distinct_id_has_sent_flag_calls = SizeLimitedHash.new(Defaults::MAX_HASH_SIZE) { |hash, key| hash[key] = Array.new }
 
       at_exit { @worker_thread && @worker_thread[:should_exit] = true }
     end
@@ -82,9 +85,16 @@ class PostHog
     #
     # @option attrs [String] :event Event name
     # @option attrs [Hash] :properties Event properties (optional)
+    # @option attrs [Bool] :send_feature_flags Whether to send feature flags with this event (optional)
     # @macro common_attrs
     def capture(attrs)
       symbolize_keys! attrs
+
+      if attrs[:send_feature_flags]
+        feature_variants = @feature_flags_poller.get_feature_variants(attrs[:distinct_id], attrs[:groups])
+        attrs[:feature_variants] = feature_variants
+      end
+
       enqueue(FieldParser.parse_for_capture(attrs))
     end
 
@@ -99,6 +109,19 @@ class PostHog
       enqueue(FieldParser.parse_for_identify(attrs))
     end
 
+    # Identifies a group
+    #
+    # @param [Hash] attrs
+    #
+    # @option attrs [String] :group_type Group type
+    # @option attrs [String] :group_key Group key
+    # @option attrs [Hash] :properties Group properties (optional)
+    # @macro common_attrs
+    def group_identify(attrs)
+      symbolize_keys! attrs
+      enqueue(FieldParser.parse_for_group_identify(attrs))
+    end
+
     # Aliases a user from one id to another
     #
     # @param [Hash] attrs
@@ -120,36 +143,72 @@ class PostHog
       @queue.length
     end
 
-    def is_feature_enabled(flag_key, distinct_id, default_value = false)
-      unless @personal_api_key
-        logger.error(
-          'You need to specify a personal_api_key to use feature flags'
-        )
-        return
+    def is_feature_enabled(flag_key, distinct_id, groups: {}, person_properties: {}, group_properties: {}, only_evaluate_locally: false, send_feature_flag_events: true)
+      response = get_feature_flag(flag_key, distinct_id, groups: groups, person_properties: person_properties, group_properties: group_properties, only_evaluate_locally: only_evaluate_locally, send_feature_flag_events: send_feature_flag_events)
+      if response.nil?
+        return nil
       end
-      is_enabled =
-        @feature_flags_poller.is_feature_enabled(
-          flag_key,
-          distinct_id,
-          default_value
-        )
-      capture(
-        {
-          'distinct_id': distinct_id,
-          'event': '$feature_flag_called',
-          'properties': {
-            '$feature_flag': flag_key,
-            '$feature_flag_response': is_enabled
+      !!response
+    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] 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.
+    # @param [Hash] group_properties
+    # 
+    # @return [String, nil] The value of the feature flag
+    #
+    # The provided properties are used to calculate feature flags locally, if possible.
+    #
+    # `groups` are a mapping from group type to group key. So, if you have a group type of "organization" and a group key of "5",
+    # you would pass groups={"organization": "5"}.
+    # `group_properties` take the format: { group_type_name: { group_properties } }
+    # So, for example, if you have the group type "organization" and the group key "5", with the properties name, and employee count,
+    # you'll send these as:
+    # ```ruby
+    #     group_properties: {"organization": {"name": "PostHog", "employees": 11}}
+    # ```
+    def get_feature_flag(key, distinct_id, groups: {}, person_properties: {}, group_properties: {}, only_evaluate_locally: false, send_feature_flag_events: true)
+      feature_flag_response, flag_was_locally_evaluated = @feature_flags_poller.get_feature_flag(key, distinct_id, groups, person_properties, group_properties, only_evaluate_locally)
+
+      feature_flag_reported_key = "#{key}_#{feature_flag_response}"
+      if !@distinct_id_has_sent_flag_calls[distinct_id].include?(feature_flag_reported_key) && send_feature_flag_events
+        capture(
+          {
+            'distinct_id': distinct_id,
+            'event': '$feature_flag_called',
+            'properties': {
+              '$feature_flag' => key,
+              '$feature_flag_response' => feature_flag_response,
+              'locally_evaluated' => flag_was_locally_evaluated
+            },
+            'groups': groups,
           }
-        }
-      )
-      return is_enabled
+        )
+        @distinct_id_has_sent_flag_calls[distinct_id] << feature_flag_reported_key
+      end
+      feature_flag_response
+    end
+
+    # Returns all flags for a given user
+    #
+    # @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.
+    # @param [Hash] group_properties
+    # 
+    # @return [Hash] String (not symbol) key value pairs of flag and their values
+    def get_all_flags(distinct_id, groups: {}, person_properties: {}, group_properties: {}, only_evaluate_locally: false)
+      return @feature_flags_poller.get_all_flags(distinct_id, groups, person_properties, group_properties, only_evaluate_locally)
     end
 
     def reload_feature_flags
       unless @personal_api_key
         logger.error(
-          'You need to specify a personal_api_key to use feature flags'
+          'You need to specify a personal_api_key to locally evaluate feature flags'
         )
         return
       end

data/lib/posthog/defaults.rb

@@ -1,5 +1,8 @@
 class PostHog
   module Defaults
+
+    MAX_HASH_SIZE = 50_000
+
     module Request
       HOST = 'app.posthog.com'
       PORT = 443

data/lib/posthog/feature_flags.rb

@@ -4,116 +4,386 @@ require 'json'
 require 'posthog/version'
 require 'posthog/logging'
 require 'digest'
+
 class PostHog
+
+  class InconclusiveMatchError < StandardError
+  end
+
+  class DecideAPIError < StandardError
+  end
+
   class FeatureFlagsPoller
     include PostHog::Logging
+    include PostHog::Utils
 
     def initialize(polling_interval, personal_api_key, project_api_key, host)
-      @polling_interval = polling_interval || 60 * 5
+      @polling_interval = polling_interval || 30
       @personal_api_key = personal_api_key
       @project_api_key = project_api_key
-      @host = host || 'app.posthog.com'
+      @host = host
       @feature_flags = Concurrent::Array.new
+      @group_type_mapping = Concurrent::Hash.new
       @loaded_flags_successfully_once = Concurrent::AtomicBoolean.new
 
       @task =
         Concurrent::TimerTask.new(
           execution_interval: polling_interval,
-          timeout_interval: 15
         ) { _load_feature_flags }
 
-      # load once before timer
-      load_feature_flags
-      @task.execute
+      # If no personal API key, disable local evaluation & thus polling for definitions
+      if @personal_api_key.nil?
+        logger.info "No personal API key provided, disabling local evaluation"
+        @loaded_flags_successfully_once.make_true
+      else
+        # load once before timer
+        load_feature_flags
+        @task.execute
+      end
     end
 
-    def is_feature_enabled(key, distinct_id, default_result = false)
+    def load_feature_flags(force_reload = false)
+      if @loaded_flags_successfully_once.false? || force_reload
+        _load_feature_flags
+      end
+    end
+
+    def get_feature_variants(distinct_id, groups={}, person_properties={}, group_properties={})
+
+      request_data = {
+        "distinct_id": distinct_id,
+        "groups": groups,
+        "person_properties": person_properties,
+        "group_properties": group_properties,
+      }
+
+      decide_data = _request_feature_flag_evaluation(request_data)
+
+      if !decide_data.key?(:featureFlags)
+        raise DecideAPIError.new(decide_data.to_json)
+      else
+        stringify_keys(decide_data[:featureFlags] || {})
+      end
+    end
+
+    def get_feature_flag(key, distinct_id, groups = {}, person_properties = {}, group_properties = {}, only_evaluate_locally = false)
       # make sure they're loaded on first run
       load_feature_flags
 
-      return default_result unless @loaded_flags_successfully_once
+      symbolize_keys! groups
+      symbolize_keys! person_properties
+      symbolize_keys! group_properties
 
-      feature_flag = nil
+      group_properties.each do |key, value|
+        symbolize_keys! value
+      end
 
+      response = nil
+      feature_flag = nil
 
       @feature_flags.each do |flag|
-        if key == flag['key']
+        if key == flag[:key]
           feature_flag = flag
           break
         end
       end
 
-      return default_result if !feature_flag
+      if !feature_flag.nil?
+        begin
+          response = _compute_flag_locally(feature_flag, distinct_id, groups, person_properties, group_properties)
+          logger.debug "Successfully computed flag locally: #{key} -> #{response}"
+        rescue InconclusiveMatchError => e
+          logger.debug "Failed to compute flag #{key} locally: #{e}"
+        rescue StandardError => e
+          logger.error "Error computing flag locally: #{e}. #{e.backtrace.join("\n")}"
+        end
+      end
 
-      flag_rollout_pctg =
-        if feature_flag['rollout_percentage']
-          feature_flag['rollout_percentage']
-        else
-          100
+      flag_was_locally_evaluated = !response.nil?
+
+      if !flag_was_locally_evaluated && !only_evaluate_locally
+        begin
+          flags = get_feature_variants(distinct_id, groups, person_properties, group_properties)
+          response = flags[key]
+          if response.nil?
+            response = false
+          end
+          logger.debug "Successfully computed flag remotely: #{key} -> #{response}"
+        rescue StandardError => e
+          logger.error "Error computing flag remotely: #{e}. #{e.backtrace.join("\n")}"
         end
-      if feature_flag['is_simple_flag']
-        return is_simple_flag_enabled(key, distinct_id, flag_rollout_pctg)
-      else
-        data = { 'distinct_id' => distinct_id }
-        res = _request('POST', 'decide', false, data)
-        return res['featureFlags'].include? key
       end
 
-      return false
+      [response, flag_was_locally_evaluated]
     end
 
-    def is_simple_flag_enabled(key, distinct_id, rollout_percentage)
-      hash = Digest::SHA1.hexdigest "#{key}.#{distinct_id}"
-      return(
-        (Integer(hash[0..14], 16).to_f / 0xfffffffffffffff) <=
-          (rollout_percentage / 100)
-      )
-    end
+    def get_all_flags(distinct_id, groups = {}, person_properties = {}, group_properties = {}, only_evaluate_locally = false)
+      # returns a string hash of all flags
 
-    def load_feature_flags(force_reload = false)
-      if @loaded_flags_successfully_once.false? || force_reload
-        _load_feature_flags
+      # make sure they're loaded on first run
+      load_feature_flags
+
+      response = {}
+      fallback_to_decide = @feature_flags.empty?
+
+      @feature_flags.each do |flag|
+        begin
+          response[flag[:key]] = _compute_flag_locally(flag, distinct_id, groups, person_properties, group_properties)
+        rescue InconclusiveMatchError => e
+          fallback_to_decide = true
+        rescue StandardError => e
+          logger.error "Error computing flag locally: #{e}."
+          fallback_to_decide = true
+        end
       end
+
+      if fallback_to_decide && !only_evaluate_locally
+        begin
+          flags = get_feature_variants(distinct_id, groups, person_properties, group_properties)
+          response = {**response, **flags}
+        rescue StandardError => e
+          logger.error "Error computing flag remotely: #{e}"
+        end
+      end
+      response
     end
 
     def shutdown_poller()
       @task.shutdown
     end
 
+    # Class methods
+
+    def self.match_property(property, property_values)
+      # 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
+
+      key = property[:key].to_sym
+      value = property[:value]
+      operator = property[:operator] || 'exact'
+
+      if !property_values.key?(key)
+        raise InconclusiveMatchError.new("Property #{key} not found in property_values")
+      elsif operator == 'is_not_set'
+        raise InconclusiveMatchError.new("Operator is_not_set not supported")
+      end
+
+      override_value = property_values[key]
+
+      case operator
+      when 'exact'
+        value.is_a?(Array) ? value.include?(override_value) : value == override_value
+      when 'is_not'
+        value.is_a?(Array) ? !value.include?(override_value) : value != override_value
+      when'is_set'
+        property_values.key?(key)
+      when 'icontains'
+        override_value.to_s.downcase.include?(value.to_s.downcase)
+      when 'not_icontains'
+        !override_value.to_s.downcase.include?(value.to_s.downcase)
+      when 'regex'
+        PostHog::Utils.is_valid_regex(value.to_s) && !Regexp.new(value.to_s).match(override_value.to_s).nil?
+      when 'not_regex'
+        PostHog::Utils.is_valid_regex(value.to_s) && Regexp.new(value.to_s).match(override_value.to_s).nil?
+      when 'gt'
+        override_value.class == value.class && override_value > value
+      when 'gte'
+        override_value.class == value.class && override_value >= value
+      when 'lt'
+        override_value.class == value.class && override_value < value
+      when 'lte'
+        override_value.class == value.class && override_value <= value
+      when 'is_date_before', 'is_date_after'
+        parsed_date = PostHog::Utils::convert_to_datetime(value)
+        override_date = PostHog::Utils::convert_to_datetime(override_value)
+        if operator == 'is_date_before'
+          return override_date < parsed_date
+        else
+          return override_date > parsed_date
+        end
+      else
+        logger.error "Unknown operator: #{operator}"
+        false
+      end
+    end
+
     private
 
-    def _load_feature_flags()
-      res = _request('GET', 'api/feature_flag', true)
-      @feature_flags.clear
-      @feature_flags = res['results'].filter { |flag| flag['active'] }
-      if @loaded_flags_successfully_once.false?
-        @loaded_flags_successfully_once.make_true
+    def _compute_flag_locally(flag, distinct_id, groups = {}, person_properties = {}, group_properties = {})
+      if flag[:ensure_experience_continuity]
+        raise InconclusiveMatchError.new("Flag has experience continuity enabled")
       end
+
+      return false if !flag[:active]
+
+      flag_filters = flag[:filters] || {}
+
+      aggregation_group_type_index = flag_filters[:aggregation_group_type_index]
+      if !aggregation_group_type_index.nil?
+        group_name = @group_type_mapping[aggregation_group_type_index.to_s.to_sym]
+
+        if group_name.nil?
+          logger.warn "[FEATURE FLAGS] Unknown group type index #{aggregation_group_type_index} for feature flag #{flag[:key]}"
+          # failover to `/decide/`
+          raise InconclusiveMatchError.new("Flag has unknown group type index")
+        end
+
+        group_name_symbol = group_name.to_sym
+
+        if !groups.key?(group_name_symbol)
+          # Group flags are never enabled if appropriate `groups` aren't passed in
+          # don't failover to `/decide/`, since response will be the same
+          logger.warn "[FEATURE FLAGS] Can't compute group feature flag: #{flag[:key]} without group names passed in"
+          return false
+        end
+
+        focused_group_properties = group_properties[group_name_symbol]
+        return match_feature_flag_properties(flag, groups[group_name_symbol], focused_group_properties)
+      else
+        return match_feature_flag_properties(flag, distinct_id, person_properties)
+      end
+
     end
 
-    def _request(method, endpoint, use_personal_api_key = false, data = {})
-      uri = URI("https://#{@host}/#{endpoint}/?token=#{@project_api_key}")
-      req = nil
-      if use_personal_api_key
-        req = Net::HTTP::Get.new(uri)
-        req['Authorization'] = "Bearer #{@personal_api_key}"
+    def match_feature_flag_properties(flag, distinct_id, properties)
+      flag_filters = flag[:filters] || {}
+
+      flag_conditions = flag_filters[:groups] || []
+      is_inconclusive = false
+      result = nil
+
+      # Stable sort conditions with variant overrides to the top. This ensures that if overrides are present, they are
+      # evaluated first, and the variant override is applied to the first matching condition.
+      sorted_flag_conditions = flag_conditions.each_with_index.sort_by { |condition, idx| [condition[:variant].nil? ? 1 : -1, idx] }
+
+      sorted_flag_conditions.each do |condition, idx|
+        begin
+          if is_condition_match(flag, distinct_id, condition, properties)
+            variant_override = condition[:variant]
+            flag_multivariate = flag_filters[:multivariate] || {}
+            flag_variants = flag_multivariate[:variants] || []
+            if flag_variants.map{|variant| variant[:key]}.include?(condition[:variant])
+                variant = variant_override
+            else
+                variant = get_matching_variant(flag, distinct_id)
+            end
+            result = variant || true
+            break
+          end
+        rescue InconclusiveMatchError => e
+          is_inconclusive = true
+        end
+      end
+
+      if !result.nil?
+        return result
+      elsif is_inconclusive
+        raise InconclusiveMatchError.new("Can't determine if feature flag is enabled or not with given properties")
+      end
+
+      # We can only return False when all conditions are False
+      return false
+    end
+
+    def is_condition_match(flag, distinct_id, condition, properties)
+      rollout_percentage = condition[:rollout_percentage]
+
+      if !(condition[:properties] || []).empty?
+        if !condition[:properties].all? { |prop|
+            FeatureFlagsPoller.match_property(prop, properties)
+          }
+          return false
+        elsif rollout_percentage.nil?
+          return true
+        end
+      end
+
+      if !rollout_percentage.nil? and _hash(flag[:key], distinct_id) > (rollout_percentage.to_f/100)
+        return false
+      end
+      
+      return true
+    end
+
+    # This function takes a distinct_id and a feature flag key and returns a float between 0 and 1.
+    # Given the same distinct_id and key, it'll always return the same float. These floats are
+    # uniformly distributed between 0 and 1, so if we want to show this feature to 20% of traffic
+    # we can do _hash(key, distinct_id) < 0.2
+    def _hash(key, distinct_id, salt="")
+      hash_key = Digest::SHA1.hexdigest "#{key}.#{distinct_id}#{salt}"
+      return (Integer(hash_key[0..14], 16).to_f / 0xfffffffffffffff)
+    end
+
+    def get_matching_variant(flag, distinct_id)
+      hash_value = _hash(flag[:key], distinct_id, salt="variant")
+      matching_variant = variant_lookup_table(flag).find { |variant|
+          hash_value >= variant[:value_min] and hash_value < variant[:value_max]
+      }
+      matching_variant.nil? ? nil : matching_variant[:key]
+    end
+
+    def variant_lookup_table(flag)
+      lookup_table = []
+      value_min = 0
+      flag_filters = flag[:filters] || {}
+      variants = flag_filters[:multivariate] || {}
+      multivariates = variants[:variants] || []
+      multivariates.each do |variant|
+        value_max = value_min + variant[:rollout_percentage].to_f / 100
+        lookup_table << {'value_min': value_min, 'value_max': value_max, 'key': variant[:key]}
+        value_min = value_max
+      end
+      return lookup_table
+    end
+
+    def _load_feature_flags()
+      res = _request_feature_flag_definitions
+      @feature_flags.clear
+
+      if !res.key?(:flags)
+        logger.error "Failed to load feature flags: #{res}"
       else
-        req = Net::HTTP::Post.new(uri)
-        req['Content-Type'] = 'application/json'
-        data['token'] = @project_api_key
-        req.body = data.to_json
+        @feature_flags = res[:flags] || []        
+        @group_type_mapping = res[:group_type_mapping] || {}
+
+        logger.debug "Loaded #{@feature_flags.length} feature flags"
+        if @loaded_flags_successfully_once.false?
+          @loaded_flags_successfully_once.make_true
+        end
       end
+    end
+
+    def _request_feature_flag_definitions
+      uri = URI("#{@host}/api/feature_flag/local_evaluation?token=#{@project_api_key}")
+      req = Net::HTTP::Get.new(uri)
+      req['Authorization'] = "Bearer #{@personal_api_key}"
+
+      _request(uri, req)
+    end
 
-      req['User-Agent'] = "posthog-ruby#{PostHog::VERSION}"
+    def _request_feature_flag_evaluation(data={})
+      uri = URI("#{@host}/decide/?v=2")
+      req = Net::HTTP::Post.new(uri)
+      req['Content-Type'] = 'application/json'
+      data['token'] = @project_api_key
+      req.body = data.to_json
+
+      _request(uri, req)
+    end
+
+    def _request(uri, request_object)
+
+      request_object['User-Agent'] = "posthog-ruby#{PostHog::VERSION}"
 
       begin
         res_body = nil
-        res =
-          Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
-            res = http.request(req)
-            res_body = JSON.parse(res.body)
-            return res_body
-          end
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          res = http.request(request_object)
+          JSON.parse(res.body, {symbolize_names: true})
+        end
       rescue Timeout::Error,
              Errno::EINVAL,
              Errno::ECONNRESET,
@@ -124,6 +394,6 @@ class PostHog
         logger.debug("Unable to complete request to #{uri}")
         throw e
       end
-    end
+    end  
   end
 end

data/lib/posthog/field_parser.rb

@@ -7,15 +7,22 @@ class PostHog
       #
       # - "event"
       # - "properties"
+      # - "groups"
       def parse_for_capture(fields)
         common = parse_common_fields(fields)
 
         event = fields[:event]
         properties = fields[:properties] || {}
+        groups = fields[:groups]
 
         check_presence!(event, 'event')
         check_is_hash!(properties, 'properties')
 
+        if groups
+          check_is_hash!(groups, 'groups')
+          properties["$groups"] = groups
+        end
+
         isoify_dates! properties
 
         common.merge(
@@ -48,6 +55,33 @@ class PostHog
         )
       end
 
+      def parse_for_group_identify(fields)
+        properties = fields[:properties] || {}
+        group_type = fields[:group_type]
+        group_key = fields[:group_key]
+
+        check_presence!(group_type, 'group type')
+        check_presence!(group_key, 'group_key')
+        check_is_hash!(properties, 'properties')
+
+        distinct_id = "$#{group_type}_#{group_key}"
+        fields[:distinct_id] = distinct_id
+        common = parse_common_fields(fields)
+
+        isoify_dates! properties
+
+        common.merge(
+          {
+            event: '$groupidentify',
+            properties: {
+              "$group_type": group_type,
+              "$group_key": group_key,
+              "$group_set": properties.merge(common[:properties] || {})
+            },
+          }
+        )
+      end
+
       # In addition to the common fields, alias accepts:
       #
       # - "alias"
@@ -79,10 +113,12 @@ class PostHog
       # - "timestamp"
       # - "distinct_id"
       # - "message_id"
+      # - "send_feature_flags"
       def parse_common_fields(fields)
         timestamp = fields[:timestamp] || Time.new
         distinct_id = fields[:distinct_id]
         message_id = fields[:message_id].to_s if fields[:message_id]
+        send_feature_flags = fields[:send_feature_flags]
 
         check_timestamp! timestamp
         check_presence! distinct_id, 'distinct_id'
@@ -98,6 +134,14 @@ class PostHog
             '$lib_version' => PostHog::VERSION.to_s
           }
         }
+
+        if send_feature_flags
+          feature_variants = fields[:feature_variants]
+          feature_variants.each do |key, value|
+            parsed[:properties]["$feature/#{key}"] = value
+          end
+          parsed[:properties]["$active_feature_flags"] = feature_variants.keys
+        end
         parsed
       end
 

data/lib/posthog/logging.rb

@@ -23,6 +23,14 @@ class PostHog
     def error(msg)
       @logger.error("#{@prefix} #{msg}")
     end
+
+    def level=(severity)
+      @logger.level = severity
+    end
+
+    def level
+      @logger.level
+    end
   end
 
   module Logging
@@ -36,6 +44,7 @@ class PostHog
           else
             logger = Logger.new STDOUT
             logger.progname = 'PostHog'
+            logger.level = Logger::WARN
             logger
           end
         @logger = PrefixedLogger.new(base_logger, '[posthog-ruby]')

data/lib/posthog/send_worker.rb

@@ -28,7 +28,7 @@ class PostHog
       batch_size = options[:batch_size] || Defaults::MessageBatch::MAX_SIZE
       @batch = MessageBatch.new(batch_size)
       @lock = Mutex.new
-      @transport = Transport.new api_host: options[:api_host], skip_ssl_verification: options[:skip_ssl_verification]
+      @transport = Transport.new api_host: options[:host], skip_ssl_verification: options[:skip_ssl_verification]
     end
 
     # public: Continuously runs the loop to check for new events

data/lib/posthog/transport.rb

@@ -20,9 +20,11 @@ class PostHog
         options[:ssl] = uri.scheme == 'https'
         options[:port] = uri.port
       end
-      options[:host] ||= HOST
-      options[:port] ||= PORT
-      options[:ssl] ||= SSL
+
+      options[:host] = !options[:host].nil? ? options[:host] : HOST
+      options[:port] = !options[:port].nil? ? options[:port] : PORT
+      options[:ssl] = !options[:ssl].nil? ? options[:ssl] : SSL
+      
       @headers = options[:headers] || HEADERS
       @path = options[:path] || PATH
       @retries = options[:retries] || RETRIES

data/lib/posthog/utils.rb

@@ -1,6 +1,10 @@
 require 'securerandom'
 
 class PostHog
+
+  class InconclusiveMatchError < StandardError
+  end
+
   module Utils
     extend self
 
@@ -83,7 +87,46 @@ class PostHog
       ]
     end
 
+    def convert_to_datetime(value)
+      if value.respond_to?(:strftime)
+        parsed_date = value
+        return parsed_date
+      elsif value.respond_to?(:to_str)
+        begin
+          parsed_date = DateTime.parse(value)
+          return parsed_date
+        rescue ArgumentError => e
+          raise InconclusiveMatchError.new("#{value} is not in a valid date format")
+        end
+      else
+        raise InconclusiveMatchError.new("The date provided must be a string or date object")
+      end
+    end
+
     UTC_OFFSET_WITH_COLON = '%s%02d:%02d'
     UTC_OFFSET_WITHOUT_COLON = UTC_OFFSET_WITH_COLON.sub(':', '')
+
+    def is_valid_regex(regex)
+      begin
+        Regexp.new(regex)
+        return true
+      rescue RegexpError
+        return false
+      end
+    end
+
+    class SizeLimitedHash < Hash
+      def initialize(max_length, *args, &block)
+        super(*args, &block)
+        @max_length = max_length
+      end
+
+      def []=(key, value)
+        if length >= @max_length
+          clear
+        end
+        super
+      end
+    end
   end
 end

data/lib/posthog/version.rb

@@ -1,3 +1,3 @@
 class PostHog
-  VERSION = '1.3.0'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: posthog-ruby
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.1.0
 platform: ruby
 authors:
 - ''
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-24 00:00:00.000000000 Z
+date: 2022-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.10
 - !ruby/object:Gem::Dependency
   name: commander
   requirement: !ruby/object:Gem::Requirement
@@ -163,7 +169,7 @@ homepage: https://github.com/PostHog/posthog-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -178,8 +184,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.1.2
+signing_key: 
 specification_version: 4
 summary: PostHog library
 test_files: []