hackle-ruby-sdk 0.1.0 → 2.0.0

data/lib/hackle/events/event_processor.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Hackle
-
-  class EventProcessor
-
-    DEFAULT_FLUSH_INTERVAL = 10
-
-    def initialize(config:, event_dispatcher:)
-      @logger = config.logger
-      @event_dispatcher = event_dispatcher
-      @message_processor = MessageProcessor.new(config: config, event_dispatcher: event_dispatcher)
-      @flush_task = Concurrent::TimerTask.new(execution_interval: DEFAULT_FLUSH_INTERVAL) { flush }
-      @consume_task = nil
-      @running = false
-    end
-
-    def start!
-      return if @running
-
-      @consume_task = Thread.new { @message_processor.consuming_loop }
-      @flush_task.execute
-      @running = true
-    end
-
-    def stop!
-      return unless @running
-
-      @message_processor.produce(message: Message::Shutdown.new, non_block: false)
-      @consume_task.join(10)
-      @flush_task.shutdown
-      @event_dispatcher.shutdown
-
-      @running = false
-    end
-
-    def process(event:)
-      @message_processor.produce(message: Message::Event.new(event))
-    end
-
-    def flush
-      @message_processor.produce(message: Message::Flush.new)
-    end
-
-    class Message
-      class Event < Message
-        attr_reader :event
-
-        def initialize(event)
-          @event = event
-        end
-      end
-
-      class Flush < Message
-      end
-
-      class Shutdown < Message
-      end
-    end
-
-    class MessageProcessor
-
-      DEFAULT_MESSAGE_QUEUE_CAPACITY = 1000
-      DEFAULT_MAX_EVENT_DISPATCH_SIZE = 500
-
-      def initialize(config:, event_dispatcher:)
-        @logger = config.logger
-        @event_dispatcher = event_dispatcher
-        @message_queue = SizedQueue.new(DEFAULT_MESSAGE_QUEUE_CAPACITY)
-        @random = Random.new
-        @consumed_events = []
-      end
-
-      def produce(message:, non_block: true)
-        @message_queue.push(message, non_block)
-      rescue ThreadError
-        if @random.rand(1..100) == 1 # log only 1% of the time
-          @logger.warn { 'Events are produced faster than can be consumed. Some events will be dropped.' }
-        end
-      end
-
-      def consuming_loop
-        loop do
-          message = @message_queue.pop
-          case message
-          when Message::Event
-            consume_event(event: message.event)
-          when Message::Flush
-            dispatch_events
-          when Message::Shutdown
-            break
-          end
-        end
-      rescue => e
-        @logger.warn { "Uncaught exception in events message processor: #{e.inspect}" }
-      ensure
-        dispatch_events
-      end
-
-      private
-
-      def consume_event(event:)
-        @consumed_events << event
-        dispatch_events if @consumed_events.length >= DEFAULT_MAX_EVENT_DISPATCH_SIZE
-      end
-
-      def dispatch_events
-        return if @consumed_events.empty?
-
-        @event_dispatcher.dispatch(events: @consumed_events)
-        @consumed_events = []
-      end
-    end
-  end
-end

data/lib/hackle/http/http.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-
-module Hackle
-  class UnexpectedResponseError < StandardError
-  end
-
-  class HTTP
-    def self.client(base_uri:)
-      uri = URI.parse(base_uri)
-      client = Net::HTTP.new(uri.host, uri.port)
-      client.use_ssl = uri.scheme == 'https'
-      client.open_timeout = 5
-      client.read_timeout = 10
-      client
-    end
-
-    def self.sdk_headers(sdk_info:)
-      {
-        'X-HACKLE-SDK-KEY' => sdk_info.key,
-        'X-HACKLE-SDK-NAME' => sdk_info.name,
-        'X-HACKLE-SDK-VERSION' => sdk_info.version
-      }
-    end
-
-    def self.successful?(status_code:)
-      status_code >= 200 && status_code < 300
-    end
-
-    def self.check_successful(status_code:)
-      unless successful?(status_code: status_code)
-        raise UnexpectedResponseError, "HTTP status code #{status_code}"
-      end
-    end
-  end
-end

data/lib/hackle/models/bucket.rb

@@ -1,15 +0,0 @@
-module Hackle
-  class Bucket
-    attr_reader :seed, :slot_size
-
-    def initialize(seed:, slot_size:, slots:)
-      @seed = seed
-      @slot_size = slot_size
-      @slots = slots
-    end
-
-    def get_slot(slot_number:)
-      @slots.find { |slot| slot.contains?(slot_number: slot_number) }
-    end
-  end
-end

data/lib/hackle/models/event_type.rb

@@ -1,14 +0,0 @@
-module Hackle
-  class EventType
-    attr_reader :id, :key
-
-    def initialize(id:, key:)
-      @id = id
-      @key = key
-    end
-
-    def self.undefined(key:)
-      EventType.new(id: 0, key: key)
-    end
-  end
-end

data/lib/hackle/models/experiment.rb

@@ -1,36 +0,0 @@
-module Hackle
-  class Experiment
-    attr_reader :id, :key
-
-    class Running < Experiment
-      attr_reader :bucket
-
-      def initialize(id:, key:, bucket:, variations:, user_overrides:)
-        @id = id
-        @key = key
-        @bucket = bucket
-        @variations = variations
-        @user_overrides = user_overrides
-      end
-
-      def get_variation(variation_id:)
-        @variations[variation_id]
-      end
-
-      def get_overridden_variation(user_id:)
-        variation_id = @user_overrides[user_id]
-        get_variation(variation_id: variation_id)
-      end
-    end
-
-    class Completed < Experiment
-      attr_reader :winner_variation_key
-
-      def initialize(id:, key:, winner_variation_key:)
-        @id = id
-        @key = key
-        @winner_variation_key = winner_variation_key
-      end
-    end
-  end
-end

data/lib/hackle/models/slot.rb

@@ -1,15 +0,0 @@
-module Hackle
-  class Slot
-    attr_reader :variation_id
-
-    def initialize(start_inclusive:, end_exclusive:, variation_id:)
-      @start_inclusive = start_inclusive
-      @end_exclusive = end_exclusive
-      @variation_id = variation_id
-    end
-
-    def contains?(slot_number:)
-      @start_inclusive <= slot_number && slot_number < @end_exclusive
-    end
-  end
-end

data/lib/hackle/models/variation.rb

@@ -1,11 +0,0 @@
-module Hackle
-  class Variation
-    attr_reader :id, :key, :dropped
-
-    def initialize(id:, key:, dropped:)
-      @id = id
-      @key = key
-      @dropped = dropped
-    end
-  end
-end

data/lib/hackle/workspaces/http_workspace_fetcher.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Hackle
-  class HttpWorkspaceFetcher
-
-    def initialize(config:, sdk_info:)
-      @client = HTTP.client(base_uri: config.base_uri)
-      @headers = HTTP.sdk_headers(sdk_info: sdk_info)
-    end
-
-    def fetch
-      request = Net::HTTP::Get.new('/api/v1/workspaces', @headers)
-      response = @client.request(request)
-
-      status_code = response.code.to_i
-      HTTP.check_successful(status_code: status_code)
-
-      response_body = JSON.parse(response.body, symbolize_names: true)
-      Workspace.create(data: response_body)
-    end
-  end
-end

data/lib/hackle/workspaces/polling_workspace_fetcher.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent'
-
-module Hackle
-  class PollingWorkspaceFetcher
-
-    DEFAULT_POLLING_INTERVAL = 10
-
-    def initialize(config:, http_fetcher:)
-      @logger = config.logger
-      @http_fetcher = http_fetcher
-      @current_workspace = Concurrent::AtomicReference.new
-      @task = Concurrent::TimerTask.new(execution_interval: DEFAULT_POLLING_INTERVAL) { poll }
-      @running = false
-    end
-
-    def fetch
-      @current_workspace.get
-    end
-
-    def start!
-      return if @running
-
-      poll
-      @task.execute
-      @running = true
-    end
-
-    def stop!
-      return unless @running
-
-      @task.shutdown
-      @running = false
-    end
-
-    def poll
-      workspace = @http_fetcher.fetch
-      @current_workspace.set(workspace)
-    rescue => e
-      @logger.error { "Failed to poll Workspace: #{e.inspect}" }
-    end
-  end
-end

data/lib/hackle/workspaces/workspace.rb

@@ -1,87 +0,0 @@
-module Hackle
-  class Workspace
-    def initialize(experiments:, event_types:)
-      @experiments = experiments
-      @event_types = event_types
-    end
-
-    def get_experiment(experiment_key:)
-      @experiments[experiment_key]
-    end
-
-    def get_event_type(event_type_key:)
-      event_type = @event_types[event_type_key]
-
-      if event_type.nil?
-        EventType.undefined(key: event_type_key)
-      else
-        event_type
-      end
-    end
-
-    class << self
-      def create(data:)
-        buckets = Hash[data[:buckets].map { |b| [b[:id], bucket(b)] }]
-        running_experiments = Hash[data[:experiments].map { |re| [re[:key], running_experiment(re, buckets)] }]
-        completed_experiment = Hash[data[:completedExperiments].map { |ce| [ce[:experimentKey], completed_experiment(ce)] }]
-        event_types = Hash[data[:events].map { |e| [e[:key], event_type(e)] }]
-        experiments = running_experiments.merge(completed_experiment)
-        Workspace.new(
-          experiments: experiments,
-          event_types: event_types
-        )
-      end
-
-      private
-
-      def running_experiment(data, buckets)
-        Experiment::Running.new(
-          id: data[:id],
-          key: data[:key],
-          bucket: buckets[data[:bucketId]],
-          variations: Hash[data[:variations].map { |v| [v[:id], variation(v)] }],
-          user_overrides: Hash[data[:execution][:userOverrides].map { |u| [u[:userId], u[:variationId]] }]
-        )
-      end
-
-      def completed_experiment(data)
-        Experiment::Completed.new(
-          id: data[:experimentId],
-          key: data[:experimentKey],
-          winner_variation_key: data[:winnerVariationKey]
-        )
-      end
-
-      def variation(data)
-        Variation.new(
-          id: data[:id],
-          key: data[:key],
-          dropped: data[:status] == 'DROPPED'
-        )
-      end
-
-      def bucket(data)
-        Bucket.new(
-          seed: data[:seed],
-          slot_size: data[:slotSize],
-          slots: data[:slots].map { |s| slot(s) }
-        )
-      end
-
-      def slot(data)
-        Slot.new(
-          start_inclusive: data[:startInclusive],
-          end_exclusive: data[:endExclusive],
-          variation_id: data[:variationId]
-        )
-      end
-
-      def event_type(data)
-        EventType.new(
-          id: data[:id],
-          key: data[:key]
-        )
-      end
-    end
-  end
-end