hackle-ruby-sdk 0.0.1 → 1.0.0

data/lib/{hackle-ruby-sdk → hackle}/events/event_processor.rb

@@ -6,10 +6,12 @@ module Hackle
 
     DEFAULT_FLUSH_INTERVAL = 10
 
-    def initialize(config, event_dispatcher)
+    # @param config [Config]
+    # @param event_dispatcher [EventDispatcher]
+    def initialize(config:, event_dispatcher:)
       @logger = config.logger
       @event_dispatcher = event_dispatcher
-      @message_processor = MessageProcessor.new(event_dispatcher, config)
+      @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
@@ -26,7 +28,9 @@ module Hackle
     def stop!
       return unless @running
 
-      @message_processor.produce(Message::Shutdown.new, non_block: false)
+      @logger.info { 'Shutting down Hackle event_processor' }
+
+      @message_processor.produce(message: Message::Shutdown.new, non_block: false)
       @consume_task.join(10)
       @flush_task.shutdown
       @event_dispatcher.shutdown
@@ -34,18 +38,22 @@ module Hackle
       @running = false
     end
 
-    def process(event)
-      @message_processor.produce(Message::Event.new(event))
+    # @param event [UserEvent]
+    def process(event:)
+      @message_processor.produce(message: Message::Event.new(event))
     end
 
     def flush
-      @message_processor.produce(Message::Flush.new)
+      @message_processor.produce(message: Message::Flush.new)
     end
 
     class Message
       class Event < Message
+
+        # @return [UserEvent]
         attr_reader :event
 
+        # @param event [UserEvent]
         def initialize(event)
           @event = event
         end
@@ -63,7 +71,7 @@ module Hackle
       DEFAULT_MESSAGE_QUEUE_CAPACITY = 1000
       DEFAULT_MAX_EVENT_DISPATCH_SIZE = 500
 
-      def initialize(event_dispatcher, config)
+      def initialize(config:, event_dispatcher:)
         @logger = config.logger
         @event_dispatcher = event_dispatcher
         @message_queue = SizedQueue.new(DEFAULT_MESSAGE_QUEUE_CAPACITY)
@@ -71,7 +79,9 @@ module Hackle
         @consumed_events = []
       end
 
-      def produce(message, non_block: true)
+      # @param message [Message]
+      # @param non_block [boolean]
+      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
@@ -84,7 +94,7 @@ module Hackle
           message = @message_queue.pop
           case message
           when Message::Event
-            consume_event(message.event)
+            consume_event(event: message.event)
           when Message::Flush
             dispatch_events
           when Message::Shutdown
@@ -99,7 +109,8 @@ module Hackle
 
       private
 
-      def consume_event(event)
+      # @param event [UserEvent]
+      def consume_event(event:)
         @consumed_events << event
         dispatch_events if @consumed_events.length >= DEFAULT_MAX_EVENT_DISPATCH_SIZE
       end
@@ -107,7 +118,7 @@ module Hackle
       def dispatch_events
         return if @consumed_events.empty?
 
-        @event_dispatcher.dispatch(@consumed_events)
+        @event_dispatcher.dispatch(events: @consumed_events)
         @consumed_events = []
       end
     end

data/lib/hackle/events/user_event.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Hackle
+
+  class UserEvent
+
+    # @!attribute [r] timestamp
+    #  @return [Integer]
+    # @!attribute [r] user
+    #  @return [User]
+    attr_reader :timestamp, :user
+
+    # @param user [User]
+    def initialize(user:)
+      @timestamp = UserEvent.generate_timestamp
+      @user = user
+    end
+
+    class Exposure < UserEvent
+
+      # @!attribute [r] experiment
+      #  @return [Experiment]
+      # @!attribute [r] variation
+      #  @return [Variation]
+      attr_reader :experiment, :variation
+
+      # @param user [User]
+      # @param experiment [Experiment]
+      # @param variation [Variation]
+      def initialize(user:, experiment:, variation:)
+        super(user: user)
+        @experiment = experiment
+        @variation = variation
+      end
+    end
+
+
+    class Track < UserEvent
+
+      # @!attribute [r] event_type
+      #  @return [EventType]
+      # @!attribute [r] event
+      #  @return [Event]
+      attr_reader :event_type, :event
+
+      # @param user [User]
+      # @param event_type [EventType]
+      # @param event [Event]
+      def initialize(user:, event_type:, event:)
+        super(user: user)
+        @event_type = event_type
+        @event = event
+      end
+    end
+
+    # @return [Integer]
+    def self.generate_timestamp
+      (Time.now.to_f * 1000).to_i
+    end
+  end
+end

data/lib/{hackle-ruby-sdk → hackle}/http/http.rb

@@ -4,14 +4,10 @@ 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)
+    def self.client(base_uri:)
       uri = URI.parse(base_uri)
       client = Net::HTTP.new(uri.host, uri.port)
       client.use_ssl = uri.scheme == 'https'
@@ -20,7 +16,7 @@ module Hackle
       client
     end
 
-    def self.sdk_headers(sdk_info)
+    def self.sdk_headers(sdk_info:)
       {
         'X-HACKLE-SDK-KEY' => sdk_info.key,
         'X-HACKLE-SDK-NAME' => sdk_info.name,
@@ -28,12 +24,14 @@ module Hackle
       }
     end
 
-    def self.successful?(status_code)
+    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)
+    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

@@ -0,0 +1,26 @@
+module Hackle
+
+  class Bucket
+
+    # @!attribute [r] seed
+    #  @return [Integer]
+    # @!attribute [r] slot_size
+    #  @return [Integer]
+    attr_reader :seed, :slot_size
+
+    # @param seed [Integer]
+    # @param slot_size [Integer]
+    # @param slots [Array]
+    def initialize(seed:, slot_size:, slots:)
+      @seed = seed
+      @slot_size = slot_size
+      @slots = slots
+    end
+
+    # @param slot_number [Integer]
+    # @return [Slot, nil]
+    def get_slot(slot_number:)
+      @slots.find { |slot| slot.contains?(slot_number: slot_number) }
+    end
+  end
+end

data/lib/hackle/models/event.rb

@@ -0,0 +1,26 @@
+module Hackle
+  class Event
+
+    # @!attribute [r] key
+    #   @return [String]
+    # @!attribute [r] value
+    #   @return [Float, nil]
+    # @!attribute [r] properties
+    #   @return [Hash]
+    attr_reader :key, :value, :properties
+
+
+    # @param key [String]
+    # @param value [Float, nil]
+    # @param properties [Hash{Symbol => String, Number, boolean}]
+    def initialize(key:, value:, properties:)
+      @key = key
+      @value = value
+      @properties = properties
+    end
+
+    def valid?
+      !key.nil? && key.is_a?(String)
+    end
+  end
+end

data/lib/hackle/models/event_type.rb

@@ -0,0 +1,22 @@
+module Hackle
+  class EventType
+
+    # @!attribute [r] id
+    #  @return [Integer]
+    # @!attribute [r] key
+    #  @return [String]
+    attr_reader :id, :key
+
+    # @param id [Integer]
+    # @param key [String]
+    def initialize(id:, key:)
+      @id = id
+      @key = key
+    end
+
+    # @param key [String]
+    def self.undefined(key:)
+      EventType.new(id: 0, key: key)
+    end
+  end
+end

data/lib/hackle/models/experiment.rb

@@ -0,0 +1,69 @@
+module Hackle
+  class Experiment
+
+    # @!attribute [r] id
+    #   @return [Integer]
+    # @!attribute [r] key
+    #   @return [Integer]
+    attr_reader :id, :key
+
+    # @param id [Integer]
+    # @param key [Integer]
+    def initialize(id:, key:)
+      @id = id
+      @key = key
+    end
+
+    class Running < Experiment
+
+      # @!attribute [r] bucket
+      #   @return [Bucket]
+      attr_reader :bucket
+
+      # @param id [Integer]
+      # @param key [Integer]
+      # @param bucket [Bucket]
+      # @param variations [Hash{String => Variation}]
+      # @param overrides [Hash{String => Integer}]
+      def initialize(id:, key:, bucket:, variations:, overrides:)
+        super(id: id, key: key)
+        @bucket = bucket
+
+        # @type [Hash{String => Variation}]
+        @variations = variations
+
+        # @type [Hash{String => Integer}]
+        @overrides = overrides
+      end
+
+      # @param variation_id [Integer]
+      # @return [Variation, nil]
+      def get_variation(variation_id:)
+        @variations[variation_id]
+      end
+
+      # @param user [User]
+      # @return [Variation, nil]
+      def get_overridden_variation(user:)
+        overridden_variation_id = @overrides[user.id]
+        return nil if overridden_variation_id.nil?
+        get_variation(variation_id: overridden_variation_id)
+      end
+    end
+
+    class Completed < Experiment
+
+      # @!attribute [r] winner_variation_key
+      #  @return [String]
+      attr_reader :winner_variation_key
+
+      # @param id [Integer]
+      # @param key [Integer]
+      # @param winner_variation_key [String]
+      def initialize(id:, key:, winner_variation_key:)
+        super(id: id, key: key)
+        @winner_variation_key = winner_variation_key
+      end
+    end
+  end
+end

data/lib/hackle/models/slot.rb

@@ -0,0 +1,22 @@
+module Hackle
+  class Slot
+    # @!attribute variation_id
+    #   @return [Integer]
+    attr_reader :variation_id
+
+    # @param start_inclusive [Integer]
+    # @param end_exclusive [Integer]
+    # @param variation_id [Integer]
+    def initialize(start_inclusive:, end_exclusive:, variation_id:)
+      @start_inclusive = start_inclusive
+      @end_exclusive = end_exclusive
+      @variation_id = variation_id
+    end
+
+    # @param slot_number [Integer]
+    # @return [boolean]
+    def contains?(slot_number:)
+      @start_inclusive <= slot_number && slot_number < @end_exclusive
+    end
+  end
+end

data/lib/hackle/models/user.rb

@@ -0,0 +1,24 @@
+module Hackle
+
+  class User
+
+    # @!attribute [r] id
+    #   @return [String]
+    # @!attribute [r] properties
+    #   @return [Hash]
+    attr_reader :id, :properties
+
+    #
+    # @param id [String]
+    # @param properties [Hash]
+    #
+    def initialize(id:, properties:)
+      @id = id
+      @properties = properties
+    end
+
+    def valid?
+      !id.nil? && id.is_a?(String)
+    end
+  end
+end

data/lib/hackle/models/variation.rb

@@ -0,0 +1,21 @@
+module Hackle
+  class Variation
+
+    # @!attribute id
+    #   @return [Integer]
+    # @!attribute key
+    #   @return [String]
+    # @!attribute dropped
+    #   @return [boolean]
+    attr_reader :id, :key, :dropped
+
+    # @param id [Integer]
+    # @param key [String]
+    # @param dropped [boolean]
+    def initialize(id:, key:, dropped:)
+      @id = id
+      @key = key
+      @dropped = dropped
+    end
+  end
+end

data/lib/{hackle-ruby-sdk → hackle}/version.rb

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

data/lib/hackle/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(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