ablaevent-ruby 2.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 593ac5ac8af6a3e678b7af74f678f28c1b13bcd90c414c90b853d000f4b3b822
+  data.tar.gz: 0b901a391a410da624d1ddd2e2fc570de473174be9afa03c3990265259790d20
+SHA512:
+  metadata.gz: 4d77f12b6e30ca51d9b30db45eaec75ae6491e6546b9d93feb1a139bb848fc734c140a10e5f9ffaf40b4c0533b8ee8a9a859b88ea7ba4aa0449c4c0821ee8353
+  data.tar.gz: 6eb786e2594776410e06227be296d96f7c0f038f2567de11a2924dd66685befc229303a1417bbad38cea404bf6c443d8543e8b809748ee9dbd8998e92c1794ac

data/bin/posthog

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+
+require 'posthog'
+require 'rubygems'
+require 'commander/import'
+require 'time'
+require 'json'
+
+program :name, 'posthog'
+program :version, '1.0.0'
+program :description, 'PostHog API'
+
+def json_hash(str)
+  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 '--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.flush
+  end
+end
+
+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 '--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.flush
+  end
+end
+
+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 '--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.flush
+  end
+end

data/lib/posthog/backoff_policy.rb

@@ -0,0 +1,44 @@
+require 'posthog/defaults'
+
+class PostHog
+  class BackoffPolicy
+    include PostHog::Defaults::BackoffPolicy
+
+    # @param [Hash] opts
+    # @option opts [Numeric] :min_timeout_ms The minimum backoff timeout
+    # @option opts [Numeric] :max_timeout_ms The maximum backoff timeout
+    # @option opts [Numeric] :multiplier The value to multiply the current
+    #   interval with for each retry attempt
+    # @option opts [Numeric] :randomization_factor The randomization factor
+    #   to use to create a range around the retry interval
+    def initialize(opts = {})
+      @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
+
+      @attempts = 0
+    end
+
+    # @return [Numeric] the next backoff interval, in milliseconds.
+    def next_interval
+      interval = @min_timeout_ms * (@multiplier**@attempts)
+      interval = add_jitter(interval, @randomization_factor)
+
+      @attempts += 1
+
+      [interval, @max_timeout_ms].min
+    end
+
+    private
+
+    def add_jitter(base, randomization_factor)
+      random_number = rand
+      max_deviation = base * randomization_factor
+      deviation = random_number * max_deviation
+
+      random_number < 0.5 ? base - deviation : base + deviation
+    end
+  end
+end

data/lib/posthog/client.rb

@@ -0,0 +1,291 @@
+require 'thread'
+require 'time'
+
+require 'posthog/defaults'
+require 'posthog/logging'
+require 'posthog/utils'
+require 'posthog/send_worker'
+require 'posthog/noop_worker'
+require 'posthog/feature_flags'
+
+class PostHog
+  class Client
+    include PostHog::Utils
+    include PostHog::Logging
+
+    # @param [Hash] opts
+    # @option opts [String] :api_key Your project's api_key
+    # @option opts [FixNum] :max_queue_size Maximum number of calls to be
+    #   remain queued. Defaults to 10_000.
+    # @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://e.abla.io`
+    # @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://e.abla.io'
+
+      @queue = Queue.new
+      @api_key = opts[:api_key]
+      @max_queue_size = opts[:max_queue_size] || Defaults::Queue::MAX_SIZE
+      @worker_mutex = Mutex.new
+      @worker = if opts[:test_mode]
+        NoopWorker.new(@queue)
+      else
+        SendWorker.new(@queue, @api_key, opts)
+      end
+      @worker_thread = nil
+      @feature_flags_poller = nil
+      @personal_api_key = opts[:personal_api_key]
+
+      check_api_key!
+
+      @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
+
+    # Synchronously waits until the worker has cleared the queue.
+    #
+    # Use only for scripts which are not long-running, and will specifically
+    # exit
+    def flush
+      while !@queue.empty? || @worker.is_requesting?
+        ensure_worker_running
+        sleep(0.1)
+      end
+    end
+
+    # Clears the queue without waiting.
+    #
+    # Use only in test mode
+    def clear
+      @queue.clear
+    end
+
+    # @!macro common_attrs
+    #   @option attrs [String] :message_id ID that uniquely
+    #     identifies a message across the API. (optional)
+    #   @option attrs [Time] :timestamp When the event occurred (optional)
+    #   @option attrs [String] :distinct_id The ID for this user in your database
+
+    # Captures an event
+    #
+    # @param [Hash] attrs
+    #
+    # @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_active_feature_variants(attrs[:distinct_id], attrs[:groups])
+
+        attrs[:feature_variants] = feature_variants
+      end
+
+      enqueue(FieldParser.parse_for_capture(attrs))
+    end
+
+    # Identifies a user
+    #
+    # @param [Hash] attrs
+    #
+    # @option attrs [Hash] :properties User properties (optional)
+    # @macro common_attrs
+    def identify(attrs)
+      symbolize_keys! attrs
+      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
+    #
+    # @option attrs [String] :alias The alias to give the distinct id
+    # @macro common_attrs
+    def alias(attrs)
+      symbolize_keys! attrs
+      enqueue(FieldParser.parse_for_alias(attrs))
+    end
+
+    # @return [Hash] pops the last message from the queue
+    def dequeue_last_message
+      @queue.pop
+    end
+
+    # @return [Fixnum] number of messages in the queue
+    def queued_messages
+      @queue.length
+    end
+
+    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
+      !!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,
+          }
+        )
+        @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
+
+    # Returns payload for a given feature flag
+    #
+    # @param [String] 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
+    # @option [Hash] person_properties key-value pairs of properties to associate with the user.
+    # @option [Hash] group_properties
+    # @option [Boolean] only_evaluate_locally
+    #
+    def get_feature_flag_payload(key, distinct_id, match_value: nil, groups: {}, person_properties: {}, group_properties: {}, only_evaluate_locally: false)
+      @feature_flags_poller.get_feature_flag_payload(key, distinct_id, match_value, groups, person_properties, group_properties, only_evaluate_locally)
+    end
+
+    # Returns all flags and payloads for a given user
+    #
+    # @param [String] distinct_id The distinct id of the user
+    # @option [Hash] groups
+    # @option [Hash] person_properties key-value pairs of properties to associate with the user.
+    # @option [Hash] group_properties
+    # @option [Boolean] only_evaluate_locally
+    #
+    def get_all_flags_and_payloads(distinct_id, groups: {}, person_properties: {}, group_properties: {}, only_evaluate_locally: false)
+      @feature_flags_poller.get_all_flags_and_payloads(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 locally evaluate 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.
+    #
+    # returns Boolean of whether the item was added to the queue.
+    def enqueue(action)
+      # add our request id for tracing purposes
+      action[:messageId] ||= uid
+
+      if @queue.length < @max_queue_size
+        @queue << action
+        ensure_worker_running
+
+        true
+      else
+        logger.warn(
+          'Queue is full, dropping events. The :max_queue_size ' \
+            'configuration parameter can be increased to prevent this from ' \
+            'happening.'
+        )
+        false
+      end
+    end
+
+    # private: Checks that the api_key is properly initialized
+    def check_api_key!
+      raise ArgumentError, 'API key must be initialized' if @api_key.nil?
+    end
+
+    def ensure_worker_running
+      return if worker_running?
+      @worker_mutex.synchronize do
+        return if worker_running?
+        @worker_thread = Thread.new { @worker.run }
+      end
+    end
+
+    def worker_running?
+      @worker_thread && @worker_thread.alive?
+    end
+  end
+end

data/lib/posthog/defaults.rb

@@ -0,0 +1,39 @@
+class PostHog
+  module Defaults
+
+    MAX_HASH_SIZE = 50_000
+
+    module Request
+      HOST = 'e.abla.io'
+      PORT = 443
+      PATH = '/batch/'
+      SSL = true
+      HEADERS = {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json',
+        'User-Agent' => "posthog-ruby/#{PostHog::VERSION}"
+      }
+      RETRIES = 10
+    end
+
+    module Queue
+      MAX_SIZE = 10_000
+    end
+
+    module Message
+      MAX_BYTES = 32_768 # 32Kb
+    end
+
+    module MessageBatch
+      MAX_BYTES = 512_000 # 500Kb
+      MAX_SIZE = 100
+    end
+
+    module BackoffPolicy
+      MIN_TIMEOUT_MS = 100
+      MAX_TIMEOUT_MS = 10_000
+      MULTIPLIER = 1.5
+      RANDOMIZATION_FACTOR = 0.5
+    end
+  end
+end