posthog-ruby 1.0.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 29cd0e26ad5127ff3cc539fbc5067e54aed04dec
-  data.tar.gz: 27d38a306c512d50e6d9fa5c6596183b6def5fc4
+SHA256:
+  metadata.gz: be0160975e0d4abe505d4039ab4191fa4ccdffa99ceba59d739ad1304a5c7c6f
+  data.tar.gz: faa21af01aaaa6de4baa0e346b9565cd477d6163483bbaf27730b6bf4dd83bc5
 SHA512:
-  metadata.gz: 579d13012057cca600cd4ce2620409e4970248129410ea3af6db07799499c753fb61ea2bcd2b0b98e89f3c921a2c0f1d3196de68c520139cd5caa6351d7eec4e
-  data.tar.gz: 86ee3522f8c0ca41088d06ec9fd67543d2721f35c09b3f19d601060f186a92a9d27744a7f8547aae91dc9f2d150a6edea8a2151a70ff7cbac0992c6d819fd104
+  metadata.gz: e7596b4aed0d4b93a321a26aee5d3f74cf5b115ecf43b98387e1e3a48e52aa48199cfa8b3ca073080d6b1ba317e77ce6bf661b5b7e1e72aefd2f61820db1df17
+  data.tar.gz: 9e2a238eec77c66beb7c69d4bfc129aae81900f02bb73afeb602ba59f4763af817f9f971504d6ad3f6f6ea48c22403e821aa624d69fd079354b431b9af190b8b

data/bin/posthog

@@ -11,32 +11,39 @@ program :version, '1.0.0'
 program :description, 'PostHog API'
 
 def json_hash(str)
-  if str
-    return JSON.parse(str)
-  end
+  return JSON.parse(str) if str
 end
 
 command :capture do |c|
   c.description = 'capture an event'
 
   c.option '--api-key=<string>', String, 'The PostHog API Key'
-  c.option '--api-host=<url>', String, 'The PostHog API URL host part (scheme+domain)'
-  c.option '--distinct-id=<distinct_id>', String, 'The distinct id to send the event as'
+  c.option '--api-host=<url>',
+           String,
+           'The PostHog API URL host part (scheme+domain)'
+  c.option '--distinct-id=<distinct_id>',
+           String,
+           'The distinct id to send the event as'
   c.option '--event=<event>', String, 'The event name to send with the event'
   c.option '--properties=<properties>', 'The properties to send (JSON-encoded)'
 
   c.action do |args, options|
-    posthog = PostHog::Client.new({
-      api_key: options.api_key,
-      api_host: options.api_host,
-      on_error: Proc.new { |status, msg| print msg }
-    })
-
-    posthog.capture({
-      distinct_id: options.distinct_id,
-      event: options.event,
-      properties: json_hash(options.properties)
-    })
+    posthog =
+      PostHog::Client.new(
+        {
+          api_key: options.api_key,
+          api_host: options.api_host,
+          on_error: Proc.new { |status, msg| print msg }
+        }
+      )
+
+    posthog.capture(
+      {
+        distinct_id: options.distinct_id,
+        event: options.event,
+        properties: json_hash(options.properties)
+      }
+    )
 
     posthog.flush
   end
@@ -46,21 +53,30 @@ command :identify do |c|
   c.description = 'identify the user'
 
   c.option '--api-key=<api_key>', String, 'The PostHog API Key'
-  c.option '--api-host=<url>', String, 'The PostHog API URL host part (scheme+domain)'
-  c.option '--distinct-id=<distinct_id>', String, 'The distinct id to send the event as'
+  c.option '--api-host=<url>',
+           String,
+           'The PostHog API URL host part (scheme+domain)'
+  c.option '--distinct-id=<distinct_id>',
+           String,
+           'The distinct id to send the event as'
   c.option '--properties=<properties>', 'The properties to send (JSON-encoded)'
 
   c.action do |args, options|
-    posthog = PostHog::Client.new({
-      api_key: options.api_key,
-      api_host: options.api_host,
-      on_error: Proc.new { |status, msg| print msg }
-    })
-
-    posthog.identify({
-      distinct_id: options.distinct_id,
-      properties: json_hash(options.properties)
-    })
+    posthog =
+      PostHog::Client.new(
+        {
+          api_key: options.api_key,
+          api_host: options.api_host,
+          on_error: Proc.new { |status, msg| print msg }
+        }
+      )
+
+    posthog.identify(
+      {
+        distinct_id: options.distinct_id,
+        properties: json_hash(options.properties)
+      }
+    )
 
     posthog.flush
   end
@@ -70,21 +86,23 @@ command :alias do |c|
   c.description = 'set an alias for a distinct id'
 
   c.option '--api-key=<api_key>', String, 'The PostHog API Key'
-  c.option '--api-host=<url>', String, 'The PostHog API URL host part (scheme+domain)'
+  c.option '--api-host=<url>',
+           String,
+           'The PostHog API URL host part (scheme+domain)'
   c.option '--distinct-id=<distinct_id>', String, 'The distinct id'
   c.option '--alias=<alias>', 'The alias to give to the distinct id'
 
   c.action do |args, options|
-    posthog = PostHog::Client.new({
-      api_key: options.api_key,
-      api_host: options.api_host,
-      on_error: Proc.new { |status, msg| print msg }
-    })
-
-    posthog.alias({
-      distinct_id: options.distinct_id,
-      alias: options.alias,
-    })
+    posthog =
+      PostHog::Client.new(
+        {
+          api_key: options.api_key,
+          api_host: options.api_host,
+          on_error: Proc.new { |status, msg| print msg }
+        }
+      )
+
+    posthog.alias({ distinct_id: options.distinct_id, alias: options.alias })
 
     posthog.flush
   end

data/lib/posthog/backoff_policy.rb

@@ -15,7 +15,8 @@ class PostHog
       @min_timeout_ms = opts[:min_timeout_ms] || MIN_TIMEOUT_MS
       @max_timeout_ms = opts[:max_timeout_ms] || MAX_TIMEOUT_MS
       @multiplier = opts[:multiplier] || MULTIPLIER
-      @randomization_factor = opts[:randomization_factor] || RANDOMIZATION_FACTOR
+      @randomization_factor =
+        opts[:randomization_factor] || RANDOMIZATION_FACTOR
 
       @attempts = 0
     end
@@ -37,11 +38,7 @@ class PostHog
       max_deviation = base * randomization_factor
       deviation = random_number * max_deviation
 
-      if random_number < 0.5
-        base - deviation
-      else
-        base + deviation
-      end
+      random_number < 0.5 ? base - deviation : base + deviation
     end
   end
 end

data/lib/posthog/client.rb

@@ -5,6 +5,7 @@ require 'posthog/defaults'
 require 'posthog/logging'
 require 'posthog/utils'
 require 'posthog/worker'
+require 'posthog/feature_flags'
 
 class PostHog
   class Client
@@ -25,9 +26,22 @@ class PostHog
       @worker_mutex = Mutex.new
       @worker = Worker.new(@queue, @api_key, opts)
       @worker_thread = nil
+      @feature_flags_poller = nil
+      @personal_api_key = nil
 
       check_api_key!
 
+      if opts[:personal_api_key].present?
+        @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
+
       at_exit { @worker_thread && @worker_thread[:should_exit] = true }
     end
 
@@ -87,6 +101,47 @@ 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
+      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
+          }
+        }
+      )
+      return is_enabled
+    end
+
+    def reload_feature_flags
+      unless @personal_api_key
+        logger.error(
+          'You need to specify a personal_api_key to use feature flags'
+        )
+        return
+      end
+      @feature_flags_poller.load_feature_flags(true)
+    end
+
+    def shutdown
+      @feature_flags_poller.shutdown_poller
+      flush
+    end
+
     private
 
     # private: Enqueues the action.
@@ -104,8 +159,8 @@ class PostHog
       else
         logger.warn(
           'Queue is full, dropping events. The :max_queue_size ' \
-          'configuration parameter can be increased to prevent this from ' \
-          'happening.'
+            'configuration parameter can be increased to prevent this from ' \
+            'happening.'
         )
         false
       end
@@ -120,9 +175,7 @@ class PostHog
       return if worker_running?
       @worker_mutex.synchronize do
         return if worker_running?
-        @worker_thread = Thread.new do
-          @worker.run
-        end
+        @worker_thread = Thread.new { @worker.run }
       end
     end
 
@@ -131,4 +184,3 @@ class PostHog
     end
   end
 end
-

data/lib/posthog/defaults.rb

@@ -1,22 +1,24 @@
 class PostHog
   module Defaults
     module Request
-      HOST = 't.posthog.com'
+      HOST = 'app.posthog.com'
       PORT = 443
       PATH = '/batch/'
       SSL = true
-      HEADERS = { 'Accept' => 'application/json',
-                  'Content-Type' => 'application/json',
-                  'User-Agent' => "posthog-ruby/#{PostHog::VERSION}" }
+      HEADERS = {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json',
+        'User-Agent' => "posthog-ruby/#{PostHog::VERSION}"
+      }
       RETRIES = 10
     end
 
     module Queue
-      MAX_SIZE = 10000
+      MAX_SIZE = 10_000
     end
 
     module Message
-      MAX_BYTES = 32768 # 32Kb
+      MAX_BYTES = 32_768 # 32Kb
     end
 
     module MessageBatch
@@ -26,7 +28,7 @@ class PostHog
 
     module BackoffPolicy
       MIN_TIMEOUT_MS = 100
-      MAX_TIMEOUT_MS = 10000
+      MAX_TIMEOUT_MS = 10_000
       MULTIPLIER = 1.5
       RANDOMIZATION_FACTOR = 0.5
     end

data/lib/posthog/feature_flags.rb

@@ -0,0 +1,129 @@
+require 'concurrent'
+require 'net/http'
+require 'json'
+require 'posthog/version'
+require 'posthog/logging'
+require 'digest'
+class PostHog
+  class FeatureFlagsPoller
+    include PostHog::Logging
+
+    def initialize(polling_interval, personal_api_key, project_api_key, host)
+      @polling_interval = polling_interval || 60 * 5
+      @personal_api_key = personal_api_key
+      @project_api_key = project_api_key
+      @host = host || 'app.posthog.com'
+      @feature_flags = Concurrent::Array.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
+    end
+
+    def is_feature_enabled(key, distinct_id, default_result = false)
+      # make sure they're loaded on first run
+      load_feature_flags
+
+      return default_result unless @loaded_flags_successfully_once
+
+      feature_flag = nil
+
+
+      @feature_flags.each do |flag|
+        if key == flag['key']
+          feature_flag = flag
+          break
+        end
+      end
+
+      return default_result if !feature_flag
+
+      flag_rollout_pctg =
+        if feature_flag['rollout_percentage']
+          feature_flag['rollout_percentage']
+        else
+          100
+        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
+    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 load_feature_flags(force_reload = false)
+      if @loaded_flags_successfully_once.false? || force_reload
+        _load_feature_flags
+      end
+    end
+
+    def shutdown_poller()
+      @task.shutdown
+    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
+      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}"
+      else
+        req = Net::HTTP::Post.new(uri)
+        req['Content-Type'] = 'application/json'
+        data['token'] = @project_api_key
+        req.body = data.to_json
+      end
+
+      req['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
+      rescue Timeout::Error,
+             Errno::EINVAL,
+             Errno::ECONNRESET,
+             EOFError,
+             Net::HTTPBadResponse,
+             Net::HTTPHeaderSyntaxError,
+             Net::ProtocolError => e
+        logger.debug("Unable to complete request to #{uri}")
+        throw e
+      end
+    end
+  end
+end

data/lib/posthog/field_parser.rb

@@ -18,11 +18,13 @@ class PostHog
 
         isoify_dates! properties
 
-        common.merge({
-          :type => 'capture',
-          :event => event.to_s,
-          :properties => properties.merge(common[:properties] || {})
-        })
+        common.merge(
+          {
+            type: 'capture',
+            event: event.to_s,
+            properties: properties.merge(common[:properties] || {})
+          }
+        )
       end
 
       # In addition to the common fields, identify accepts:
@@ -36,12 +38,14 @@ class PostHog
 
         isoify_dates! properties
 
-        common.merge({
-          :type => 'identify',
-          :event => '$identify',
-          :'$set' => properties,
-          :properties => properties.merge(common[:properties] || {})
-        })
+        common.merge(
+          {
+            type: 'identify',
+            event: '$identify',
+            '$set': properties,
+            properties: properties.merge(common[:properties] || {})
+          }
+        )
       end
 
       # In addition to the common fields, alias accepts:
@@ -55,15 +59,17 @@ class PostHog
         alias_field = fields[:alias]
         check_presence! alias_field, 'alias'
 
-        common.merge({
-          :type => 'alias',
-          :event => '$create_alias',
-          :distinct_id => nil,
-          :properties => {
-            :distinct_id => distinct_id,
-            :alias => alias_field,
-          }.merge(common[:properties] || {})
-        })
+        common.merge(
+          {
+            type: 'alias',
+            event: '$create_alias',
+            distinct_id: nil,
+            properties:
+              { distinct_id: distinct_id, alias: alias_field }.merge(
+                common[:properties] || {}
+              )
+          }
+        )
       end
 
       private
@@ -82,21 +88,23 @@ class PostHog
         check_presence! distinct_id, 'distinct_id'
 
         parsed = {
-          :timestamp => datetime_in_iso8601(timestamp),
-          :library => 'posthog-ruby',
-          :library_version => PostHog::VERSION.to_s,
-          :messageId => message_id,
-          :distinct_id => distinct_id,
-          :properties => {
-            "$lib" => 'posthog-ruby',
-            "$lib_version" => PostHog::VERSION.to_s
+          timestamp: datetime_in_iso8601(timestamp),
+          library: 'posthog-ruby',
+          library_version: PostHog::VERSION.to_s,
+          messageId: message_id,
+          distinct_id: distinct_id,
+          properties: {
+            '$lib' => 'posthog-ruby',
+            '$lib_version' => PostHog::VERSION.to_s
           }
         }
         parsed
       end
 
       def check_timestamp!(timestamp)
-        raise ArgumentError, 'Timestamp must be a Time' unless timestamp.is_a? Time
+        unless timestamp.is_a? Time
+          raise ArgumentError, 'Timestamp must be a Time'
+        end
       end
 
       # private: Ensures that a string is non-empty

data/lib/posthog/logging.rb

@@ -30,13 +30,14 @@ class PostHog
       def logger
         return @logger if @logger
 
-        base_logger = if defined?(Rails)
-                        Rails.logger
-                      else
-                        logger = Logger.new STDOUT
-                        logger.progname = 'PostHog'
-                        logger
-                      end
+        base_logger =
+          if defined?(Rails)
+            Rails.logger
+          else
+            logger = Logger.new STDOUT
+            logger.progname = 'PostHog'
+            logger
+          end
         @logger = PrefixedLogger.new(base_logger, '[posthog-ruby]')
       end
 
@@ -56,4 +57,3 @@ class PostHog
     end
   end
 end
-

data/lib/posthog/message_batch.rb

@@ -4,7 +4,8 @@ require 'posthog/logging'
 class PostHog
   # A batch of `Message`s to be sent to the API
   class MessageBatch
-    class JSONGenerationError < StandardError; end
+    class JSONGenerationError < StandardError
+    end
 
     extend Forwardable
     include PostHog::Logging

data/lib/posthog/response.rb

@@ -7,8 +7,7 @@ class PostHog
     #
     def initialize(status = 200, error = nil)
       @status = status
-      @error  = error
+      @error = error
     end
   end
 end
-

data/lib/posthog/transport.rb

@@ -26,13 +26,15 @@ class PostHog
       @headers = options[:headers] || HEADERS
       @path = options[:path] || PATH
       @retries = options[:retries] || RETRIES
-      @backoff_policy =
-        options[:backoff_policy] || PostHog::BackoffPolicy.new
+      @backoff_policy = options[:backoff_policy] || PostHog::BackoffPolicy.new
 
       http = Net::HTTP.new(options[:host], options[:port])
       http.use_ssl = options[:ssl]
       http.read_timeout = 8
       http.open_timeout = 4
+      if options[:skip_ssl_verification]
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
 
       @http = http
     end
@@ -43,15 +45,16 @@ class PostHog
     def send(api_key, batch)
       logger.debug("Sending request for #{batch.length} items")
 
-      last_response, exception = retry_with_backoff(@retries) do
-        status_code, body = send_request(api_key, batch)
-        error = JSON.parse(body)['error']
-        should_retry = should_retry_request?(status_code, body)
-        logger.debug("Response status code: #{status_code}")
-        logger.debug("Response error: #{error}") if error
+      last_response, exception =
+        retry_with_backoff(@retries) do
+          status_code, body = send_request(api_key, batch)
+          error = JSON.parse(body)['error']
+          should_retry = should_retry_request?(status_code, body)
+          logger.debug("Response status code: #{status_code}")
+          logger.debug("Response error: #{error}") if error
 
-        [Response.new(status_code, error), should_retry]
-      end
+          [Response.new(status_code, error), should_retry]
+        end
 
       if exception
         logger.error(exception.message)
@@ -95,7 +98,7 @@ class PostHog
 
       begin
         result, should_retry = yield
-        return [result, nil] unless should_retry
+        return result, nil unless should_retry
       rescue StandardError => e
         should_retry = true
         caught_exception = e
@@ -112,16 +115,13 @@ class PostHog
 
     # Sends a request for the batch, returns [status_code, body]
     def send_request(api_key, batch)
-      payload = JSON.generate(
-        api_key: api_key,
-        batch: batch
-      )
+      payload = JSON.generate(api_key: api_key, batch: batch)
 
       request = Net::HTTP::Post.new(@path, @headers)
 
       if self.class.stub
         logger.debug "stubbed request to #{@path}: " \
-          "api key = #{api_key}, batch = #{JSON.generate(batch)}"
+                       "api key = #{api_key}, batch = #{JSON.generate(batch)}"
 
         [200, '{}']
       else
@@ -140,4 +140,3 @@ class PostHog
     end
   end
 end
-

data/lib/posthog/utils.rb

@@ -7,9 +7,7 @@ class PostHog
     # public: Return a new hash with keys converted from strings to symbols
     #
     def symbolize_keys(hash)
-      hash.each_with_object({}) do |(k, v), memo|
-        memo[k.to_sym] = v
-      end
+      hash.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
     end
 
     # public: Convert hash keys from strings to symbols in place
@@ -21,9 +19,7 @@ class PostHog
     # public: Return a new hash with keys as strings
     #
     def stringify_keys(hash)
-      hash.each_with_object({}) do |(k, v), memo|
-        memo[k.to_s] = v
-      end
+      hash.each_with_object({}) { |(k, v), memo| memo[k.to_s] = v }
     end
 
     # public: Returns a new hash with all the date values in the into iso8601
@@ -64,9 +60,8 @@ class PostHog
     end
 
     def time_in_iso8601(time, fraction_digits = 3)
-      fraction = if fraction_digits > 0
-                   ('.%06i' % time.usec)[0, fraction_digits + 1]
-                 end
+      fraction =
+        (('.%06i' % time.usec)[0, fraction_digits + 1] if fraction_digits > 0)
 
       "#{time.strftime('%Y-%m-%dT%H:%M:%S')}#{fraction}#{formatted_offset(time, true, 'Z')}"
     end
@@ -76,15 +71,19 @@ class PostHog
     end
 
     def formatted_offset(time, colon = true, alternate_utc_string = nil)
-      time.utc? && alternate_utc_string || seconds_to_utc_offset(time.utc_offset, colon)
+      time.utc? && alternate_utc_string ||
+        seconds_to_utc_offset(time.utc_offset, colon)
     end
 
     def seconds_to_utc_offset(seconds, colon = true)
-      (colon ? UTC_OFFSET_WITH_COLON : UTC_OFFSET_WITHOUT_COLON) % [(seconds < 0 ? '-' : '+'), (seconds.abs / 3600), ((seconds.abs % 3600) / 60)]
+      (colon ? UTC_OFFSET_WITH_COLON : UTC_OFFSET_WITHOUT_COLON) % [
+        (seconds < 0 ? '-' : '+'),
+        (seconds.abs / 3600),
+        ((seconds.abs % 3600) / 60)
+      ]
     end
 
     UTC_OFFSET_WITH_COLON = '%s%02d:%02d'
     UTC_OFFSET_WITHOUT_COLON = UTC_OFFSET_WITH_COLON.sub(':', '')
   end
 end
-

data/lib/posthog/version.rb

@@ -1,3 +1,3 @@
 class PostHog
-  VERSION = '1.0.1'
+  VERSION = '1.2.2'
 end

data/lib/posthog/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]
+      @transport = Transport.new api_host: options[:api_host], skip_ssl_verification: options[:skip_ssl_verification]
     end
 
     # public: Continuously runs the loop to check for new events
@@ -65,4 +65,3 @@ class PostHog
     end
   end
 end
-

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: posthog-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.2
 platform: ruby
 authors:
 - ''
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-20 00:00:00.000000000 Z
+date: 2021-11-22 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: commander
   requirement: !ruby/object:Gem::Requirement
@@ -135,6 +149,7 @@ files:
 - lib/posthog/backoff_policy.rb
 - lib/posthog/client.rb
 - lib/posthog/defaults.rb
+- lib/posthog/feature_flags.rb
 - lib/posthog/field_parser.rb
 - lib/posthog/logging.rb
 - lib/posthog/message_batch.rb
@@ -162,8 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: PostHog library