hackle-ruby-sdk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 81db70f8f36a1dca6c3f03bfef469313434fd8f17e053ab32baee9c7f029f8ac
+  data.tar.gz: beb13a5d67bbb19d4e7a11556021cc8ca911d8e20902d191fc98973aa0683581
+SHA512:
+  metadata.gz: a8c56e2a506eb133d44bbcce75cfe523e29105813147a458b0bef4728e90fa833f630b9a4432c9b7642ba1c201397755dd501eec4db5f69c55d311dbbdeaeee8
+  data.tar.gz: 1685a42a07a605653b86b3b7af369abdde427dba4308fcf763c9a4a3fad07ddcd87b1ba6a1561d2cb84ff14b878f86eea34e7b4aea1206a358e168961cb70fca

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--order random

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 1.17.3

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hackle-ruby-sdk.gemspec
+gemspec

data/README.md

@@ -0,0 +1,35 @@
+# Hackle::Ruby::Sdk
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/hackle/ruby/sdk`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hackle-ruby-sdk'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hackle-ruby-sdk
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/hackle-ruby-sdk.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/hackle-ruby-sdk.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hackle-ruby-sdk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hackle-ruby-sdk'
+  spec.version       = Hackle::VERSION
+  spec.authors       = ['Hackle']
+  spec.email         = ['platform@hackle.io']
+  spec.summary       = 'Hackle SDK for Ruby'
+  spec.description   = 'Hackle SDK for Ruby'
+  spec.homepage      = 'https://github.com/hackle-io/hackle-ruby-sdk'
+  spec.license       = 'Apache-2.0'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec)/}) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '0.73.0'
+
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
+  spec.add_runtime_dependency 'json', '>= 1.8'
+  spec.add_runtime_dependency 'murmurhash3', '~> 0.1'
+end

data/lib/hackle-ruby-sdk.rb

@@ -0,0 +1,22 @@
+require 'hackle-ruby-sdk/decision/bucketer'
+require 'hackle-ruby-sdk/decision/decider'
+
+require 'hackle-ruby-sdk/events/event'
+require 'hackle-ruby-sdk/events/event_dispatcher'
+require 'hackle-ruby-sdk/events/event_processor'
+
+require 'hackle-ruby-sdk/http/http'
+
+require 'hackle-ruby-sdk/models/bucket'
+require 'hackle-ruby-sdk/models/event_type'
+require 'hackle-ruby-sdk/models/experiment'
+require 'hackle-ruby-sdk/models/slot'
+require 'hackle-ruby-sdk/models/variation'
+
+require 'hackle-ruby-sdk/workspaces/http_workspace_fetcher'
+require 'hackle-ruby-sdk/workspaces/polling_workspace_fetcher'
+require 'hackle-ruby-sdk/workspaces/workspace'
+
+require 'hackle-ruby-sdk/client'
+require 'hackle-ruby-sdk/config'
+require 'hackle-ruby-sdk/version'

data/lib/hackle-ruby-sdk/client.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Hackle
+
+  #
+  # A client for Hackle API.
+  #
+  class Client
+    def initialize(config, workspace_fetcher, event_processor, decider)
+      @logger = config.logger
+      @workspace_fetcher = workspace_fetcher
+      @event_processor = event_processor
+      @decider = decider
+    end
+
+    #
+    # Decide the variation to expose to the user for experiment.
+    #
+    # This method return the control variation 'A' if:
+    # - The experiment key is invalid
+    # - The experiment has not started yet
+    # - The user is not allocated to the experiment
+    # - The decided variation has been dropped
+    #
+    # @param experiment_key [Integer] The unique key of the experiment.
+    # @param user_id [String] The identifier of your customer. (e.g. user_email, account_id, decide_id, etc.)
+    # @param default_variation [String] The default variation of the experiment.
+    #
+    # @return [String] The decided variation for the user, or default variation
+    #
+    def variation(experiment_key, user_id, default_variation = 'A')
+
+      return default_variation if experiment_key.nil?
+      return default_variation if user_id.nil?
+
+      workspace = @workspace_fetcher.fetch
+      return default_variation if workspace.nil?
+
+      experiment = workspace.get_experiment(experiment_key)
+      return default_variation if experiment.nil?
+
+      decision = @decider.decide(experiment, user_id)
+      case decision
+      when Decision::NotAllocated
+        default_variation
+      when Decision::ForcedAllocated
+        decision.variation_key
+      when Decision::NaturalAllocated
+        @event_processor.process(Event::Exposure.new(user_id, experiment, decision.variation))
+        decision.variation.key
+      else
+        default_variation
+      end
+    end
+
+    #
+    # Records the events performed by the user.
+    #
+    # @param event_key [String]  The unique key of the events.
+    # @param user_id [String] The identifier of user that performed the vent.
+    # @param value [Float] Additional numeric value of the events (e.g. purchase_amount, api_latency, etc.)
+    #
+    def track(event_key, user_id, value = nil)
+
+      return if event_key.nil?
+      return if user_id.nil?
+
+      workspace = @workspace_fetcher.fetch
+      return if workspace.nil?
+
+      event_type = workspace.get_event_type(event_key)
+      return if event_type.nil?
+
+      @event_processor.process(Event::Track.new(user_id, event_type, value))
+    end
+
+    #
+    # Shutdown the background task and release the resources used for the background task.
+    #
+    def close
+      @workspace_fetcher.stop!
+      @event_processor.stop!
+    end
+
+    #
+    # Instantiates a Hackle client.
+    #
+    # @param sdk_key [String] The SDK key of your Hackle environment
+    # @param config [Config] An optional client configuration
+    #
+    # @return [Client] The Hackle client instance.
+    #
+    def self.create(sdk_key, config = Config.new)
+      sdk_info = SdkInfo.new(sdk_key)
+
+      http_workspace_fetcher = HttpWorkspaceFetcher.new(config, sdk_info)
+      polling_workspace_fetcher = PollingWorkspaceFetcher.new(config, http_workspace_fetcher)
+
+      event_dispatcher = EventDispatcher.new(config, sdk_info)
+      event_processor = EventProcessor.new(config, event_dispatcher)
+
+      polling_workspace_fetcher.start!
+      event_processor.start!
+
+      Client.new(config, polling_workspace_fetcher, event_processor, Decider.new)
+    end
+  end
+end

data/lib/hackle-ruby-sdk/config.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Hackle
+  class Config
+
+    def initialize(options = {})
+      @logger = options[:logger] || Config.default_logger
+      @base_uri = options[:base_uri] || Config.default_base_uri
+      @event_uri = options[:event_uri] || Config.default_event_uri
+    end
+
+    attr_reader :logger
+    attr_reader :base_uri
+    attr_reader :event_uri
+
+    def self.default_base_uri
+      'https://sdk.hackle.io'
+    end
+
+    def self.default_event_uri
+      'https://events.hackle.io'
+    end
+
+    def self.default_logger
+      if defined?(Rails) && Rails.logger
+        Rails.logger
+      else
+        Logger.new($stdout)
+      end
+    end
+  end
+end

data/lib/hackle-ruby-sdk/decision/bucketer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'murmurhash3'
+
+module Hackle
+  class Bucketer
+    def bucketing(bucket, user_id)
+      slot_number = calculate_slot_number(bucket.seed, bucket.slot_size, user_id)
+      bucket.get_slot(slot_number)
+    end
+
+    def calculate_slot_number(seed, slot_size, user_id)
+      hash_value = hash(user_id, seed)
+      hash_value.abs % slot_size
+    end
+
+    def hash(data, seed)
+      unsigned_value = MurmurHash3::V32.str_hash(data, seed)
+      if (unsigned_value & 0x80000000).zero?
+        unsigned_value
+      else
+        -((unsigned_value ^ 0xFFFFFFFF) + 1)
+      end
+    end
+  end
+end

data/lib/hackle-ruby-sdk/decision/decider.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Hackle
+  class Decision
+    class NotAllocated < Decision
+    end
+
+    class ForcedAllocated < Decision
+      attr_reader :variation_key
+
+      def initialize(variation_key)
+        @variation_key = variation_key
+      end
+    end
+
+    class NaturalAllocated < Decision
+      attr_reader :variation
+
+      def initialize(variation)
+        @variation = variation
+      end
+    end
+  end
+
+  class Decider
+    def initialize
+      @bucketer = Bucketer.new
+    end
+
+    def decide(experiment, user_id)
+      case experiment
+      when Experiment::Completed
+        Decision::ForcedAllocated.new(experiment.winner_variation_key)
+      when Experiment::Running
+        decide_running(experiment, user_id)
+      end
+    end
+
+    def decide_running(experiment, user_id)
+
+      overridden_variation = experiment.get_overridden_variation(user_id)
+      return Decision::ForcedAllocated.new(overridden_variation.key) unless overridden_variation.nil?
+
+      allocated_slot = @bucketer.bucketing(experiment.bucket, user_id)
+      return Decision::NotAllocated.new if allocated_slot.nil?
+
+      allocated_variation = experiment.get_variation(allocated_slot.variation_id)
+      return Decision::NotAllocated.new if allocated_variation.nil?
+      return Decision::NotAllocated.new if allocated_variation.dropped
+
+      Decision::NaturalAllocated.new(allocated_variation)
+    end
+  end
+end

data/lib/hackle-ruby-sdk/events/event.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hackle
+  class Event
+    attr_reader :timestamp, :user_id
+
+    class Exposure < Event
+      attr_reader :experiment, :variation
+
+      def initialize(user_id, experiment, variation)
+        @timestamp = Event.generate_timestamp
+        @user_id = user_id
+        @experiment = experiment
+        @variation = variation
+      end
+    end
+
+    class Track < Event
+      attr_reader :event_type, :value
+
+      def initialize(user_id, event_type, value = nil)
+        @timestamp = Event.generate_timestamp
+        @user_id = user_id
+        @event_type = event_type
+        @value = value
+      end
+    end
+
+    def self.generate_timestamp
+      (Time.now.to_f * 1000).to_i
+    end
+  end
+end

data/lib/hackle-ruby-sdk/events/event_dispatcher.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Hackle
+  class EventDispatcher
+
+    DEFAULT_DISPATCH_WORKER_SIZE = 2
+    DEFAULT_DISPATCH_QUEUE_CAPACITY = 50
+
+    def initialize(config, sdk_info)
+      @logger = config.logger
+      @client = HTTP.client(config.event_uri)
+      @headers = HTTP.sdk_headers(sdk_info)
+      @dispatcher_executor = Concurrent::ThreadPoolExecutor.new(
+        min_threads: DEFAULT_DISPATCH_WORKER_SIZE,
+        max_threads: DEFAULT_DISPATCH_WORKER_SIZE,
+        max_queue: DEFAULT_DISPATCH_QUEUE_CAPACITY
+      )
+    end
+
+    def dispatch(events)
+      payload = create_payload(events)
+      begin
+        @dispatcher_executor.post { dispatch_payload(payload) }
+      rescue Concurrent::RejectedExecutionError
+        @logger.warn { 'Dispatcher executor queue is full. Event dispatch rejected' }
+      end
+    end
+
+    def shutdown
+      @dispatcher_executor.shutdown
+      unless @dispatcher_executor.wait_for_termination(10)
+        @logger.warn { 'Failed to dispatch previously submitted events' }
+      end
+    end
+
+    private
+
+    def dispatch_payload(payload)
+      request = Net::HTTP::Post.new('/api/v1/events', @headers)
+      request.content_type = 'application/json'
+      request.body = payload.to_json
+
+      response = @client.request(request)
+
+      status_code = response.code.to_i
+      HTTP.check_successful(status_code)
+    rescue => e
+      @logger.error { "Failed to dispatch events: #{e.inspect}" }
+    end
+
+    def create_payload(events)
+      exposure_events = []
+      track_events = []
+      events.each do |event|
+        case event
+        when Event::Exposure
+          exposure_events << create_exposure_event(event)
+        when Event::Track
+          track_events << create_track_event(event)
+        end
+      end
+      {
+        exposureEvents: exposure_events,
+        trackEvents: track_events
+      }
+    end
+
+    def create_exposure_event(event)
+      {
+        timestamp: event.timestamp,
+        userId: event.user_id,
+        experimentId: event.experiment.id,
+        experimentKey: event.experiment.key,
+        variationId: event.variation.id,
+        variationKey: event.variation.key
+      }
+    end
+
+    def create_track_event(event)
+      {
+        timestamp: event.timestamp,
+        userId: event.user_id,
+        eventTypeId: event.event_type.id,
+        eventTypeKey: event.event_type.key,
+        value: event.value
+      }
+    end
+  end
+end

data/lib/hackle-ruby-sdk/events/event_processor.rb

@@ -0,0 +1,115 @@
+# 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(event_dispatcher, config)
+      @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::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::Event.new(event))
+    end
+
+    def flush
+      @message_processor.produce(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(event_dispatcher, config)
+        @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(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(@consumed_events)
+        @consumed_events = []
+      end
+    end
+  end
+end

data/lib/hackle-ruby-sdk/http/http.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Hackle
+  class UnexpectedResponseError < StandardError
+
+    def initialize(status_code)
+      super("HTTP status code #{status_code}")
+    end
+  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)
+      raise UnexpectedResponseError.new(status_code) unless successful?(status_code)
+    end
+  end
+end

data/lib/hackle-ruby-sdk/models/bucket.rb

@@ -0,0 +1,15 @@
+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) }
+    end
+  end
+end

data/lib/hackle-ruby-sdk/models/event_type.rb

@@ -0,0 +1,10 @@
+module Hackle
+  class EventType
+    attr_reader :id, :key
+
+    def initialize(id, key)
+      @id = id
+      @key = key
+    end
+  end
+end

data/lib/hackle-ruby-sdk/models/experiment.rb

@@ -0,0 +1,39 @@
+module Hackle
+  class Experiment
+    attr_reader :id, :key
+
+    def initialize(id, key)
+      @id = id
+      @key = key
+    end
+
+    class Running < Experiment
+      attr_reader :bucket
+
+      def initialize(id, key, bucket, variations, user_overrides)
+        super(id, 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)
+      end
+    end
+
+    class Completed < Experiment
+      attr_reader :winner_variation_key
+
+      def initialize(id, key, winner_variation_key)
+        super(id, key)
+        @winner_variation_key = winner_variation_key
+      end
+    end
+  end
+end

data/lib/hackle-ruby-sdk/models/slot.rb

@@ -0,0 +1,15 @@
+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-ruby-sdk/models/variation.rb

@@ -0,0 +1,11 @@
+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-ruby-sdk/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Hackle
+  VERSION = '0.0.1'
+  SDK_NAME = 'ruby-sdk'
+
+  class SdkInfo
+    attr_reader :key, :name, :version
+    def initialize(key)
+      @key = key
+      @name = SDK_NAME
+      @version = VERSION
+    end
+  end
+end

data/lib/hackle-ruby-sdk/workspaces/http_workspace_fetcher.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Hackle
+  class HttpWorkspaceFetcher
+
+    def initialize(config, sdk_info)
+      @client = HTTP.client(config.base_uri)
+      @headers = HTTP.sdk_headers(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)
+
+      data = JSON.parse(response.body, symbolize_names: true)
+      Workspace.create(data)
+    end
+  end
+end

data/lib/hackle-ruby-sdk/workspaces/polling_workspace_fetcher.rb

@@ -0,0 +1,44 @@
+# 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-ruby-sdk/workspaces/workspace.rb

@@ -0,0 +1,78 @@
+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_types[event_type_key]
+    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, event_types)
+      end
+
+      private
+
+      def running_experiment(data, buckets)
+        Experiment::Running.new(
+          data[:id],
+          data[:key],
+          buckets[data[:bucketId]],
+          Hash[data[:variations].map { |v| [v[:id], variation(v)] }],
+          Hash[data[:execution][:userOverrides].map { |u| [u[:userId], u[:variationId]] }]
+        )
+      end
+
+      def completed_experiment(data)
+        Experiment::Completed.new(
+          data[:experimentId],
+          data[:experimentKey],
+          data[:winnerVariationKey]
+        )
+      end
+
+      def variation(data)
+        Variation.new(
+          data[:id],
+          data[:key],
+          data[:status] == 'DROPPED'
+        )
+      end
+
+      def bucket(data)
+        Bucket.new(
+          data[:seed],
+          data[:slotSize],
+          data[:slots].map { |s| slot(s) }
+        )
+      end
+
+      def slot(data)
+        Slot.new(
+          data[:startInclusive],
+          data[:endExclusive],
+          data[:variationId]
+        )
+      end
+
+      def event_type(data)
+        EventType.new(
+          data[:id],
+          data[:key]
+        )
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: hackle-ruby-sdk
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Hackle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.73.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.73.0
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: murmurhash3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: Hackle SDK for Ruby
+email:
+- platform@hackle.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- hackle-ruby-sdk.gemspec
+- lib/hackle-ruby-sdk.rb
+- lib/hackle-ruby-sdk/client.rb
+- lib/hackle-ruby-sdk/config.rb
+- lib/hackle-ruby-sdk/decision/bucketer.rb
+- lib/hackle-ruby-sdk/decision/decider.rb
+- lib/hackle-ruby-sdk/events/event.rb
+- lib/hackle-ruby-sdk/events/event_dispatcher.rb
+- lib/hackle-ruby-sdk/events/event_processor.rb
+- lib/hackle-ruby-sdk/http/http.rb
+- lib/hackle-ruby-sdk/models/bucket.rb
+- lib/hackle-ruby-sdk/models/event_type.rb
+- lib/hackle-ruby-sdk/models/experiment.rb
+- lib/hackle-ruby-sdk/models/slot.rb
+- lib/hackle-ruby-sdk/models/variation.rb
+- lib/hackle-ruby-sdk/version.rb
+- lib/hackle-ruby-sdk/workspaces/http_workspace_fetcher.rb
+- lib/hackle-ruby-sdk/workspaces/polling_workspace_fetcher.rb
+- lib/hackle-ruby-sdk/workspaces/workspace.rb
+homepage: https://github.com/hackle-io/hackle-ruby-sdk
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Hackle SDK for Ruby
+test_files: []