hackle-ruby-sdk 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7ece6c3cc0981ab69f50731472d68c3f4903ccf30a5ffd5fb069210e076cc55
-  data.tar.gz: f9f19bb60c2a4d34afe50203cc4637d92939e9c1a94e8ff86f1334e38d60a515
+  metadata.gz: 2eb9518d11c4980c9a6abf036b8400fad5de381db6c60d2fc98b68e37cda8851
+  data.tar.gz: faf6536122c01e9a55f95eef4e6497313a7e09e2ff16ea1123ca6c7fdc56470a
 SHA512:
-  metadata.gz: e63f1afec1b82a27376f69db48721be968d72b7f959df243155d952159e615aa629dc1e98c473d72155769b7fca567c712e37c11efbbf3ccdee48726e1d76108
-  data.tar.gz: f89a85d084ebb33b2c788674e4fb4869bae3c5d9952126faa75374a4d07b7db382af3a93b7f3c52acbf64525bdc3e0bd652d11ab64db0637f98f8b0a593541fb
+  metadata.gz: cbf193163d0b5926f052e76b7b01e0ca472297ef5da32b2317e90a1f35450cefa6496a72bcd0e9d6c7faf83947b6a9379e07be7111f5fa0a5030b891013c6c1c
+  data.tar.gz: e9d8ed3a4439684fb0b3308edb0a2e48c36ba041fa8f081e33ddad237ee8a5b546f0c98a1ec05b5c4123f76fe9289bc2ea3e84d9b02b068a3833472eec77691e

data/lib/hackle.rb

@@ -12,7 +12,7 @@ module Hackle
   # @see Client#initialize
   #
   # @param sdk_key [String] The SDK key of your Hackle environment
-  # @param options An optional client configuration
+  # @param options Optional parameters of configuration options
   #
   # @return [Client] The Hackle client instance.
   #
@@ -36,4 +36,41 @@ module Hackle
       decider: Decider.new
     )
   end
+
+  #
+  # Instantiate a user to be used for the hackle sdk.
+  #
+  # The only required parameter is `id`, which must uniquely identify each user.
+  #
+  # @example
+  #  Hackle.user(id: 'ae2182e0')
+  #  Hackle.user(id: 'ae2182e0', app_version: '1.0.1', paying_customer: false)
+  #
+  # @param id [String] The identifier of the user. (e.g. device_id, account_id etc.)
+  # @param properties Additional properties of the user. (e.g. app_version, membership_grade, etc.)
+  #
+  # @return [User] The configured user object.
+  #
+  def self.user(id:, **properties)
+    User.new(id: id, properties: properties)
+  end
+
+  #
+  # Instantiate an event to be used for the hackle sdk.
+  #
+  # The only required parameter is `key`, which must uniquely identify each event.
+  #
+  # @example
+  #  Hackle.event(key: 'purchase')
+  #  Hackle.event(key: 'purchase', value: 42000.0, app_version: '1.0.1', payment_method: 'CARD' )
+  #
+  # @param key [String] The unique key of the events.
+  # @param value [Float] Optional numeric value of the events (e.g. purchase_amount, quantity, etc.)
+  # @param properties Additional properties of the events (e.g. app_version, os_type, etc.)
+  #
+  # @return [Event] The configured event object.
+  #
+  def self.event(key:, value: nil, **properties)
+    Event.new(key: key, value: value, properties: properties)
+  end
 end

data/lib/hackle/client.rb

@@ -3,16 +3,18 @@
 require 'hackle/decision/bucketer'
 require 'hackle/decision/decider'
 
-require 'hackle/events/event'
+require 'hackle/events/user_event'
 require 'hackle/events/event_dispatcher'
 require 'hackle/events/event_processor'
 
 require 'hackle/http/http'
 
 require 'hackle/models/bucket'
+require 'hackle/models/event'
 require 'hackle/models/event_type'
 require 'hackle/models/experiment'
 require 'hackle/models/slot'
+require 'hackle/models/user'
 require 'hackle/models/variation'
 
 require 'hackle/workspaces/http_workspace_fetcher'
@@ -36,8 +38,14 @@ module Hackle
     #
     def initialize(config:, workspace_fetcher:, event_processor:, decider:)
       @logger = config.logger
+
+      # @type [PollingWorkspaceFetcher]
       @workspace_fetcher = workspace_fetcher
+
+      # @type [EventProcessor]
       @event_processor = event_processor
+
+      # @type [Decider]
       @decider = decider
     end
 
@@ -50,16 +58,16 @@ module Hackle
     # - 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 experiment_key [Integer] The unique key of the experiment. MUST NOT be nil.
+    # @param user [User] the user to participate in the experiment. MUST NOT be nil.
     # @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')
+    def variation(experiment_key:, user:, default_variation: 'A')
 
-      return default_variation if experiment_key.nil?
-      return default_variation if user_id.nil?
+      return default_variation if experiment_key.nil? || !experiment_key.is_a?(Integer)
+      return default_variation if user.nil? || !user.is_a?(User) || !user.valid?
 
       workspace = @workspace_fetcher.fetch
       return default_variation if workspace.nil?
@@ -67,40 +75,45 @@ module Hackle
       experiment = workspace.get_experiment(experiment_key: experiment_key)
       return default_variation if experiment.nil?
 
-      decision = @decider.decide(experiment: experiment, user_id: user_id)
+      decision = @decider.decide(experiment: experiment, user: user)
       case decision
       when Decision::NotAllocated
         default_variation
       when Decision::ForcedAllocated
         decision.variation_key
       when Decision::NaturalAllocated
-        exposure_event = Event::Exposure.new(user_id: user_id, experiment: experiment, variation: decision.variation)
+        exposure_event = UserEvent::Exposure.new(user: user, experiment: experiment, variation: decision.variation)
         @event_processor.process(event: exposure_event)
         decision.variation.key
       else
         default_variation
       end
+
+    rescue => e
+      @logger.error { "Unexpected error while deciding variation for experiment[#{experiment_key}]. Returning default variation[#{default_variation}]: #{e.inspect}" }
+      default_variation
     end
 
     #
-    # Records the events performed by the user.
+    # Records the event that occurred 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.)
+    # @param event [Event] the event that occurred.
+    # @param user [User] the user that occurred the event.
     #
-    def track(event_key:, user_id:, value: nil)
+    def track(event:, user:)
 
-      return if event_key.nil?
-      return if user_id.nil?
+      return if event.nil? || !event.is_a?(Event) || !event.valid?
+      return if user.nil? || !user.is_a?(User) || !user.valid?
 
       workspace = @workspace_fetcher.fetch
       return if workspace.nil?
 
-      event_type = workspace.get_event_type(event_type_key: event_key)
-
-      track_event = Event::Track.new(user_id: user_id, event_type: event_type, value: value)
+      event_type = workspace.get_event_type(event_type_key: event.key)
+      track_event = UserEvent::Track.new(user: user, event_type: event_type, event: event)
       @event_processor.process(event: track_event)
+
+    rescue => e
+      @logger.error { "Unexpected error while tracking event: #{e.inspect}" }
     end
 
     #

data/lib/hackle/decision/bucketer.rb

@@ -4,20 +4,34 @@ require 'murmurhash3'
 
 module Hackle
   class Bucketer
-    def bucketing(bucket:, user_id:)
+
+    # @param bucket [Bucket]
+    # @param user [User]
+    #
+    # @return [Slot, nil]
+    def bucketing(bucket:, user:)
       slot_number = calculate_slot_number(
         seed: bucket.seed,
         slot_size: bucket.slot_size,
-        user_id: user_id
+        user_id: user.id
       )
       bucket.get_slot(slot_number: slot_number)
     end
 
+    # @param seed [Integer]
+    # @param slot_size [Integer]
+    # @param user_id [String]
+    #
+    # @return [Integer]
     def calculate_slot_number(seed:, slot_size:, user_id:)
       hash_value = hash(data: user_id, seed: seed)
       hash_value.abs % slot_size
     end
 
+    # @param data [String]
+    # @param seed [Integer]
+    #
+    # @return [Integer]
     def hash(data:, seed:)
       unsigned_value = MurmurHash3::V32.str_hash(data, seed)
       if (unsigned_value & 0x80000000).zero?

data/lib/hackle/decision/decider.rb

@@ -2,20 +2,25 @@
 
 module Hackle
   class Decision
+
     class NotAllocated < Decision
     end
 
     class ForcedAllocated < Decision
+      # @return [String]
       attr_reader :variation_key
 
+      # @param variation_key [String]
       def initialize(variation_key:)
         @variation_key = variation_key
       end
     end
 
     class NaturalAllocated < Decision
+      # @return [Variation]
       attr_reader :variation
 
+      # @param variation [Variation]
       def initialize(variation:)
         @variation = variation
       end
@@ -27,21 +32,31 @@ module Hackle
       @bucketer = Bucketer.new
     end
 
-    def decide(experiment:, user_id:)
+    # @param experiment [Experiment]
+    # @param user [User]
+    #
+    # @return [Decision]
+    def decide(experiment:, user:)
       case experiment
       when Experiment::Completed
         Decision::ForcedAllocated.new(variation_key: experiment.winner_variation_key)
       when Experiment::Running
-        decide_running(running_experiment: experiment, user_id: user_id)
+        decide_running(running_experiment: experiment, user: user)
+      else
+        NotAllocated.new
       end
     end
 
-    def decide_running(running_experiment:, user_id:)
+    # @param running_experiment [Experiment::Running]
+    # @param user [User]
+    #
+    # @return [Decision]
+    def decide_running(running_experiment:, user:)
 
-      overridden_variation = running_experiment.get_overridden_variation(user_id: user_id)
+      overridden_variation = running_experiment.get_overridden_variation(user: user)
       return Decision::ForcedAllocated.new(variation_key: overridden_variation.key) unless overridden_variation.nil?
 
-      allocated_slot = @bucketer.bucketing(bucket: running_experiment.bucket, user_id: user_id)
+      allocated_slot = @bucketer.bucketing(bucket: running_experiment.bucket, user: user)
       return Decision::NotAllocated.new if allocated_slot.nil?
 
       allocated_variation = running_experiment.get_variation(variation_id: allocated_slot.variation_id)

data/lib/hackle/events/event_dispatcher.rb

@@ -53,9 +53,9 @@ module Hackle
       track_events = []
       events.each do |event|
         case event
-        when Event::Exposure
+        when UserEvent::Exposure
           exposure_events << create_exposure_event(event)
-        when Event::Track
+        when UserEvent::Track
           track_events << create_track_event(event)
         end
       end
@@ -65,24 +65,31 @@ module Hackle
       }
     end
 
-    def create_exposure_event(event)
+    #
+    # @param exposure [UserEvent::Exposure]
+    #
+    def create_exposure_event(exposure)
       {
-        timestamp: event.timestamp,
-        userId: event.user_id,
-        experimentId: event.experiment.id,
-        experimentKey: event.experiment.key,
-        variationId: event.variation.id,
-        variationKey: event.variation.key
+        timestamp: exposure.timestamp,
+        userId: exposure.user.id,
+        experimentId: exposure.experiment.id,
+        experimentKey: exposure.experiment.key,
+        variationId: exposure.variation.id,
+        variationKey: exposure.variation.key
       }
     end
 
-    def create_track_event(event)
+    #
+    # @param track [UserEvent::Track]
+    #
+    def create_track_event(track)
       {
-        timestamp: event.timestamp,
-        userId: event.user_id,
-        eventTypeId: event.event_type.id,
-        eventTypeKey: event.event_type.key,
-        value: event.value
+        timestamp: track.timestamp,
+        userId: track.user.id,
+        eventTypeId: track.event_type.id,
+        eventTypeKey: track.event_type.key,
+        value: track.event.value,
+        properties: track.event.properties
       }
     end
   end

data/lib/hackle/events/event_processor.rb

@@ -6,6 +6,8 @@ module Hackle
 
     DEFAULT_FLUSH_INTERVAL = 10
 
+    # @param config [Config]
+    # @param event_dispatcher [EventDispatcher]
     def initialize(config:, event_dispatcher:)
       @logger = config.logger
       @event_dispatcher = event_dispatcher
@@ -26,6 +28,8 @@ module Hackle
     def stop!
       return unless @running
 
+      @logger.info { 'Shutting down Hackle event_processor' }
+
       @message_processor.produce(message: Message::Shutdown.new, non_block: false)
       @consume_task.join(10)
       @flush_task.shutdown
@@ -34,6 +38,7 @@ module Hackle
       @running = false
     end
 
+    # @param event [UserEvent]
     def process(event:)
       @message_processor.produce(message: Message::Event.new(event))
     end
@@ -44,8 +49,11 @@ module Hackle
 
     class Message
       class Event < Message
+
+        # @return [UserEvent]
         attr_reader :event
 
+        # @param event [UserEvent]
         def initialize(event)
           @event = event
         end
@@ -71,6 +79,8 @@ module Hackle
         @consumed_events = []
       end
 
+      # @param message [Message]
+      # @param non_block [boolean]
       def produce(message:, non_block: true)
         @message_queue.push(message, non_block)
       rescue ThreadError
@@ -99,6 +109,7 @@ module Hackle
 
       private
 
+      # @param event [UserEvent]
       def consume_event(event:)
         @consumed_events << event
         dispatch_events if @consumed_events.length >= DEFAULT_MAX_EVENT_DISPATCH_SIZE

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/models/bucket.rb

@@ -1,13 +1,24 @@
 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

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

@@ -1,12 +1,20 @@
 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

data/lib/hackle/models/experiment.rb

@@ -1,34 +1,67 @@
 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
 
-      def initialize(id:, key:, bucket:, variations:, user_overrides:)
-        @id = id
-        @key = key
+      # @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
-        @user_overrides = user_overrides
+
+        # @type [Hash{String => Integer}]
+        @overrides = overrides
       end
 
+      # @param variation_id [Integer]
+      # @return [Variation, nil]
       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)
+      # @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:)
-        @id = id
-        @key = key
+        super(id: id, key: key)
         @winner_variation_key = winner_variation_key
       end
     end

data/lib/hackle/models/slot.rb

@@ -1,13 +1,20 @@
 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

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

@@ -1,7 +1,17 @@
 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

data/lib/hackle/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Hackle
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
   SDK_NAME = 'ruby-sdk'
 
   class SdkInfo

data/lib/hackle/workspaces/polling_workspace_fetcher.rb

@@ -15,6 +15,7 @@ module Hackle
       @running = false
     end
 
+    # @return [Workspace, nil]
     def fetch
       @current_workspace.get
     end
@@ -30,6 +31,8 @@ module Hackle
     def stop!
       return unless @running
 
+      @logger.info { 'Shutting down Hackle workspace_fetcher' }
+
       @task.shutdown
       @running = false
     end

data/lib/hackle/workspaces/workspace.rb

@@ -1,14 +1,27 @@
 module Hackle
   class Workspace
+
+    # @param experiments [Hash{Integer => Experiment}]
+    # @param event_types [Hash{String => EventType}]
     def initialize(experiments:, event_types:)
+
+      # @type [Hash{Integer => Experiment}]
       @experiments = experiments
+
+      # @type [Hash{String => EventType}]
       @event_types = event_types
     end
 
+    # @param experiment_key [Integer]
+    #
+    # @return [Experiment, nil]
     def get_experiment(experiment_key:)
       @experiments[experiment_key]
     end
 
+    # @param event_type_key [String]
+    #
+    # @return [EventType]
     def get_event_type(event_type_key:)
       event_type = @event_types[event_type_key]
 
@@ -40,7 +53,7 @@ module Hackle
           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]] }]
+          overrides: Hash[data[:execution][:userOverrides].map { |u| [u[:userId], u[:variationId]] }]
         )
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hackle-ruby-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Hackle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-03 00:00:00.000000000 Z
+date: 2020-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -142,14 +142,16 @@ files:
 - lib/hackle/config.rb
 - lib/hackle/decision/bucketer.rb
 - lib/hackle/decision/decider.rb
-- lib/hackle/events/event.rb
 - lib/hackle/events/event_dispatcher.rb
 - lib/hackle/events/event_processor.rb
+- lib/hackle/events/user_event.rb
 - lib/hackle/http/http.rb
 - lib/hackle/models/bucket.rb
+- lib/hackle/models/event.rb
 - lib/hackle/models/event_type.rb
 - lib/hackle/models/experiment.rb
 - lib/hackle/models/slot.rb
+- lib/hackle/models/user.rb
 - lib/hackle/models/variation.rb
 - lib/hackle/version.rb
 - lib/hackle/workspaces/http_workspace_fetcher.rb

data/lib/hackle/events/event.rb

@@ -1,33 +0,0 @@
-# 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