posthog-ruby 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b45334d5c62eb513540ccc0b292e2b29b097785a50e53527f33ae0b6a81abc1e
-  data.tar.gz: 3bba8055756830eeb52cd8fc8c53c4a994b452b665929d4e487324d0ac94b5a1
+  metadata.gz: b1c78909b0d23aea369a70193696c779c04de90bf5c7725c2d3402c982ba2568
+  data.tar.gz: bf4c5400441cefdf1b9037b27e3b2bfd572317cd7309b30fc89ae56548a2c1c3
 SHA512:
-  metadata.gz: 94977f7338a9859aed6e556d77aa98ff9d04a0a70edd8104e3917166f7428600fa46c78a19ae21c38fc2522b413342ef0af6801f365cf95e7f1d245fc802fc93
-  data.tar.gz: 8edc603d8a4e59339538b9f52d4c73177888393e3a6abd3c6063eb9a9f46d039a3dde88185be325dbbf6e894b2f880de1b047d9706c8e4a3533d567b14fa0fbf
+  metadata.gz: 3d4c65100cf0971d2382ec47c29346fd88e2d1ceab61a82694a96ad60d28607edcc08a3f4023d13235e87350f4ac3e9ccace34d7c2138b70a850895c6fa2482c
+  data.tar.gz: 7054d04f4c9346e18c638370d39858b98dfd9653e5731bcd286556f686978d652ef414c37f040a11272030624d86858419eccab147a50c88c4ca0226916451e3

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

@@ -7,7 +7,6 @@ require 'posthog/utils'
 require 'posthog/worker'
 require 'posthog/feature_flags'
 
-
 class PostHog
   class Client
     include PostHog::Utils
@@ -34,14 +33,18 @@ class PostHog
 
       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])
+        @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
 
-    
     # Synchronously waits until the worker has flushed the queue.
     #
     # Use only for scripts which are not long-running, and will specifically
@@ -98,26 +101,37 @@ class PostHog
       @queue.length
     end
 
-    def is_feature_enabled(flag_key, distinct_id, default_value=false)
+    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')
+        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
+      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')
+        logger.error(
+          'You need to specify a personal_api_key to use feature flags'
+        )
         return
       end
       @feature_flags_poller.load_feature_flags(true)
@@ -145,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
@@ -161,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
 
@@ -172,4 +184,3 @@ class PostHog
     end
   end
 end
-

data/lib/posthog/defaults.rb

@@ -5,18 +5,20 @@ class PostHog
       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

@@ -5,119 +5,125 @@ 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) do
-            _load_feature_flags
-        end
-
-        # 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
+  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
 
-        unless @loaded_flags_successfully_once
-          return default_result
-        end
+      return default_result unless @loaded_flags_successfully_once
 
-        feature_flag = nil
+      feature_flag = nil
 
-        # puts @feature_flags
 
-        @feature_flags.each do |flag|
-          if key == flag['key']
-            feature_flag = flag
-            break
-          end
+      @feature_flags.each do |flag|
+        if key == flag['key']
+          feature_flag = flag
+          break
         end
+      end
 
-        if !feature_flag
-          return default_result
-        end
+      return default_result if !feature_flag
 
-        flag_rollout_pctg = feature_flag['rollout_percentage'] ? feature_flag['rollout_percentage'] : 100
-        if feature_flag['is_simple_flag']
-          return is_simple_flag_enabled(key, distinct_id, flag_rollout_pctg)
+      flag_rollout_pctg =
+        if feature_flag['rollout_percentage']
+          feature_flag['rollout_percentage']
         else
-          data = { 'distinct_id' => distinct_id }
-          res = _request('POST', 'decide', false, data)
-          return res['featureFlags'].include? key
+          100
         end
-
-        return false
+      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
 
-      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
+      return false
+    end
 
-      def load_feature_flags(force_reload = false)
-        if @loaded_flags_successfully_once.false? || force_reload
-          _load_feature_flags
-        end
-        
-      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 shutdown_poller()
-        @task.shutdown
+    def load_feature_flags(force_reload = false)
+      if @loaded_flags_successfully_once.false? || force_reload
+        _load_feature_flags
       end
+    end
 
-      private
+    def shutdown_poller()
+      @task.shutdown
+    end
 
-      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
+    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
+    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}"
+      req['User-Agent'] = "posthog-ruby#{PostHog::VERSION}"
 
-        begin
-          res_body = nil
-          res = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|
+      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
+      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,8 +26,7 @@ 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]
@@ -43,15 +42,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 +95,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 +112,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 +137,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.2.0'
+  VERSION = '1.2.1'
 end

data/lib/posthog/worker.rb

@@ -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.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - ''
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-18 00:00:00.000000000 Z
+date: 2021-11-19 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