amplitude-api 0.0.8 → 0.3.0

data/lib/amplitude_api/config.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+class AmplitudeAPI
+  # AmplitudeAPI::Config
+  class Config
+    include Singleton
+
+    attr_accessor :api_key, :secret_key, :whitelist, :time_formatter,
+                  :event_properties_formatter, :user_properties_formatter
+
+    def initialize
+      self.class.defaults.each { |k, v| send("#{k}=", v) }
+    end
+
+    class << self
+      def base_properties
+        %i[event_type event_properties user_properties user_id device_id]
+      end
+
+      def revenue_properties
+        %i[revenue_type product_id revenue price quantity]
+      end
+
+      def optional_properties
+        %i[
+          time
+          ip platform country insert_id
+          groups app_version os_name os_version
+          device_brand device_manufacturer device_model
+          carrier region city dma language
+          location_lat location_lng
+          idfa idfv adid android_id
+          event_id session_id
+        ]
+      end
+
+      def defaults
+        {
+          api_key: nil,
+          secret_key: nil,
+          whitelist: base_properties + revenue_properties + optional_properties,
+          time_formatter: ->(time) { time ? time.to_i * 1_000 : nil },
+          event_properties_formatter: ->(props) { props || {} },
+          user_properties_formatter: ->(props) { props || {} }
+        }
+      end
+    end
+  end
+end

data/lib/amplitude_api/event.rb

@@ -1,66 +1,55 @@
+# frozen_string_literal: true
+
+# This class is 115 lines long. It's on the limit, it should be refactored before
+# including more code.
+#
+# rubocop:disable Metrics/ClassLength
 class AmplitudeAPI
   # AmplitudeAPI::Event
   class Event
-    # @!attribute [ rw ] user_id
-    #   @return [ String ] the user_id to be sent to Amplitude
-    attr_accessor :user_id
-    # @!attribute [ rw ] event_type
-    #   @return [ String ] the event_type to be sent to Amplitude
-    attr_accessor :event_type
-    # @!attribute [ rw ] event_properties
-    #   @return [ String ] the event_properties to be attached to the Amplitude Event
-    attr_accessor :event_properties
-    # @!attribute [ rw ] user_properties
-    #   @return [ String ] the user_properties to be passed for the user
-    attr_accessor :user_properties
-    # @!attribute [ rw ] time
-    #   @return [ Time ] Time that the event occurred (defaults to now)
-    attr_accessor :time
-    # @!attribute [ rw ] ip
-    #   @return [ String ] IP address of the user
-    attr_accessor :ip
-
-    # @!attribute [ rw ] insert_id
-    #   @return [ String ] the unique identifier to be sent to Amplitude
-    attr_accessor :insert_id
-
-    # @!attribute [ rw ] price
-    #   @return [ String ] (required for revenue data) price of the item purchased
-    attr_accessor :price
-
-    # @!attribute [ rw ] quantity
-    #   @return [ String ] (required for revenue data, defaults to 1 if not specified) quantity of the item purchased
-    attr_accessor :quantity
-
-    # @!attribute [ rw ] product_id
-    #   @return [ String ] an identifier for the product. (Note: you must send a price and quantity with this field)
-    attr_accessor :product_id
-
-    # @!attribute [ rw ] revenue_type
-    #   @return [ String ] type of revenue. (Note: you must send a price and quantity with this field)
-    attr_accessor :revenue_type
+    AmplitudeAPI::Config.instance.whitelist.each do |attribute|
+      instance_eval("attr_accessor :#{attribute}", __FILE__, __LINE__)
+    end
 
     # Create a new Event
     #
-    # @param [ String ] user_id a user_id to associate with the event
-    # @param [ String ] event_type a name for the event
-    # @param [ Hash ] event_properties various properties to attach to the event
-    # @param [ Time ] Time that the event occurred (defaults to now)
-    # @param [ Double ] price (optional, but required for revenue data) price of the item purchased
-    # @param [ Integer ] quantity (optional, but required for revenue data) quantity of the item purchased
-    # @param [ String ] product_id (optional) an identifier for the product.
-    # @param [ String ] revenue_type (optional) type of revenue
-    # @param [ String ] IP address of the user
-    # @param [ String ] insert_id a unique identifier for the event
-    def initialize(options = {})
-      self.user_id = options.fetch(:user_id, '')
-      self.event_type = options.fetch(:event_type, '')
-      self.event_properties = options.fetch(:event_properties, {})
-      self.user_properties = options.fetch(:user_properties, {})
-      self.time = options[:time]
-      self.ip = options.fetch(:ip, '')
-      self.insert_id = options[:insert_id]
-      validate_revenue_arguments(options)
+    # See (Amplitude HTTP API Documentation)[https://developers.amplitude.com/docs/http-api-v2]
+    # for a list of valid parameters and their types.
+    def initialize(attributes = {})
+      attributes.each do |k, v|
+        send("#{k}=", v) if respond_to?("#{k}=")
+      end
+      validate_arguments
+      @extra_properties = []
+    end
+
+    def method_missing(method_name, *args)
+      super if block_given?
+
+      property_name = method_name.to_s.delete_suffix("=")
+
+      @extra_properties << property_name
+
+      create_setter property_name
+      create_getter property_name
+
+      send("#{property_name}=".to_sym, *args)
+    end
+
+    def create_setter(attribute_name)
+      self.class.send(:define_method, "#{attribute_name}=".to_sym) do |value|
+        instance_variable_set("@" + attribute_name.to_s, value)
+      end
+    end
+
+    def create_getter(attribute_name)
+      self.class.send(:define_method, attribute_name.to_sym) do
+        instance_variable_get("@" + attribute_name.to_s)
+      end
+    end
+
+    def respond_to_missing?(method_name, *args)
+      @extra_properties.include?(method_name) || @extra_properties.include?("#{method_name}=") || super
     end
 
     def user_id=(value)
@@ -76,43 +65,97 @@ class AmplitudeAPI
     #
     # Used for serialization and comparison
     def to_hash
-      serialized_event = {}
-      serialized_event[:event_type] = event_type
-      serialized_event[:user_id] = user_id
-      serialized_event[:event_properties] = event_properties
-      serialized_event[:user_properties] = user_properties
-      serialized_event[:time] = formatted_time if time
-      serialized_event[:ip] = ip if ip
-      serialized_event[:insert_id] = insert_id if insert_id
+      event = {
+        event_type: event_type,
+        event_properties: formatted_event_properties,
+        user_properties: formatted_user_properties
+      }
+      event[:user_id] = user_id if user_id
+      event[:device_id] = device_id if device_id
+      event.merge(optional_properties).merge(revenue_hash).merge(extra_properties)
+    end
+    alias to_h to_hash
+
+    # @return [ Hash ] Optional properties
+    #
+    # Returns optional properties (belong to the API but are optional)
+    def optional_properties
+      AmplitudeAPI::Config.optional_properties.map do |prop|
+        val = prop == :time ? formatted_time : send(prop)
+        val ? [prop, val] : nil
+      end.compact.to_h
+    end
 
-      serialized_event.merge(revenue_hash)
+    # @return [ Hash ] Extra properties
+    #
+    # Returns optional properties (not belong to the API, are assigned by the user)
+    # This way, if the API is updated with new properties, the gem will be able
+    # to work with the new specification until the code is modified
+    def extra_properties
+      @extra_properties.map do |prop|
+        val = send(prop)
+        val ? [prop.to_sym, val] : nil
+      end.compact.to_h
+    end
+
+    # @return [ true, false ]
+    #
+    # Returns true if the event type matches one reserved by Amplitude API.
+    def reserved_event?(type)
+      ["[Amplitude] Start Session",
+       "[Amplitude] End Session",
+       "[Amplitude] Revenue",
+       "[Amplitude] Revenue (Verified)",
+       "[Amplitude] Revenue (Unverified)",
+       "[Amplitude] Merged User"].include?(type)
     end
 
     # @return [ true, false ]
     #
     # Compares +to_hash+ for equality
     def ==(other)
-      if other.respond_to?(:to_hash)
-        to_hash == other.to_hash
-      else
-        false
-      end
+      return false unless other.respond_to?(:to_h)
+
+      to_h == other.to_h
     end
 
     private
 
     def formatted_time
-      time.to_i * 1_000
+      Config.instance.time_formatter.call(time)
+    end
+
+    def formatted_event_properties
+      Config.instance.event_properties_formatter.call(event_properties)
+    end
+
+    def formatted_user_properties
+      Config.instance.user_properties_formatter.call(user_properties)
     end
 
-    def validate_revenue_arguments(options)
-      self.price = options[:price]
-      self.quantity = options[:quantity] || 1 if price
-      self.product_id = options[:product_id]
-      self.revenue_type = options[:revenue_type]
-      return if price
-      raise ArgumentError, 'You must provide a price in order to use the product_id' if product_id
-      raise ArgumentError, 'You must provide a price in order to use the revenue_type' if revenue_type
+    def validate_arguments
+      validate_required_arguments
+      validate_revenue_arguments
+    end
+
+    def validate_required_arguments
+      raise ArgumentError, "You must provide user_id or device_id (or both)" unless user_id || device_id
+      raise ArgumentError, "You must provide event_type" unless event_type
+      raise ArgumentError, "Invalid event_type - cannot match a reserved event name" if reserved_event?(event_type)
+    end
+
+    def validate_revenue_arguments
+      return true if !revenue_type && !product_id
+      return true if revenue || price
+
+      raise ArgumentError, revenue_error_message
+    end
+
+    def revenue_error_message
+      error_field = "product_id" if product_id
+      error_field = "revenue_type" if revenue_type
+
+      "You must provide a price or a revenue in order to use the field #{error_field}"
     end
 
     def revenue_hash
@@ -121,7 +164,13 @@ class AmplitudeAPI
       revenue_hash[:revenueType] = revenue_type if revenue_type
       revenue_hash[:quantity] = quantity if quantity
       revenue_hash[:price] = price if price
+      revenue_hash[:revenue] = revenue if revenue
       revenue_hash
     end
+
+    def getopt(options, key, default = nil)
+      options.fetch(key.to_sym, options.fetch(key.to_s, default))
+    end
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/amplitude_api/identification.rb

@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
 class AmplitudeAPI
   # AmplitudeAPI::Identification
   class Identification
     # @!attribute [ rw ] user_id
     #   @return [ String ] the user_id to be sent to Amplitude
-    attr_accessor :user_id
+    attr_reader :user_id
+    # @!attribute [ rw ] device_id
+    #   @return [ String ] the device_id to be sent to Amplitude
+    attr_accessor :device_id
     # @!attribute [ rw ] user_properties
     #   @return [ String ] the user_properties to be attached to the Amplitude Identify
     attr_accessor :user_properties
@@ -11,9 +16,11 @@ class AmplitudeAPI
     # Create a new Identification
     #
     # @param [ String ] user_id a user_id to associate with the identification
+    # @param [ String ] device_id a device_id to associate with the identification
     # @param [ Hash ] user_properties various properties to attach to the user identification
-    def initialize(user_id: '', user_properties: {})
+    def initialize(user_id: "", device_id: nil, user_properties: {})
       self.user_id = user_id
+      self.device_id = device_id if device_id
       self.user_properties = user_properties
     end
 
@@ -33,7 +40,7 @@ class AmplitudeAPI
       {
         user_id: user_id,
         user_properties: user_properties
-      }
+      }.tap { |hsh| hsh[:device_id] = device_id if device_id }
     end
 
     # @return [ true, false ]

data/lib/amplitude_api/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AmplitudeAPI
-  VERSION = '0.0.8'.freeze
+  VERSION = "0.3.0"
 end

data/readme.md

@@ -15,10 +15,11 @@ The following code snippet will immediately track an event to the Amplitude API.
 
 ```ruby
 # Configure your Amplitude API key
-AmplitudeAPI.api_key = "abcdef123456"
+AmplitudeAPI.config.api_key = "abcdef123456"
+
 
 event = AmplitudeAPI::Event.new({
-  user_id: "123",
+  user_id: "12345",
   event_type: "clicked on home",
   time: Time.now,
   insert_id: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',
@@ -30,16 +31,32 @@ event = AmplitudeAPI::Event.new({
 AmplitudeAPI.track(event)
 ```
 
-Currently, we are using this in Rails and using ActiveJob to dispatch events asynchronously. I plan on moving background/asynchronous support into this gem.
+## User Privacy APIs
+
+The following code snippet will delete a user from amplitude
+
+```ruby
+# Configure your Amplitude API key
+AmplitudeAPI.config.api_key = "abcdef123456"
+
+# Configure your Amplitude Secret Key
+AmplitudeAPI.config.secret_key = "secretMcSecret"
+
+AmplitudeAPI.delete(user_ids: ["12345"],
+  requester: "privacy@example.com"
+)
+```
+
+Currently, we are using this in Rails and using ActiveJob to dispatch events asynchronously. I plan on moving
+background/asynchronous support into this gem.
 
 ## What's Next
 
 * Thread support for background dispatching in bulk
-* `device_id` support as an alternative to `user_id`
 * Configurable default account to use when no `user_id` present
 
 ## Other useful resources
-* [Amplitude HTTP Api Documentation](https://amplitude.zendesk.com/hc/en-us/articles/204771828)
+* [Amplitude HTTP API V2 Api Documentation](https://developers.amplitude.com/docs/http-api-v2)
 * [Segment.io Amplitude integration](https://segment.com/docs/integrations/amplitude/)
 
 ## Contributing

data/spec/lib/amplitude_api/event_spec.rb

@@ -1,183 +1,318 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe AmplitudeAPI::Event do
   user = Struct.new(:id)
 
-  context 'with a user object' do
-    describe '#body' do
+  context "with a user object" do
+    describe "#body" do
       it "populates with the user's id" do
         event = described_class.new(
           user_id: user.new(123),
-          event_type: 'clicked on home'
+          event_type: "clicked on home"
         )
         expect(event.to_hash[:user_id]).to eq(123)
       end
     end
   end
 
-  context 'with a user id' do
-    describe '#body' do
+  context "with a user id" do
+    describe "#body" do
       it "populates with the user's id" do
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home'
+          event_type: "clicked on home"
         )
         expect(event.to_hash[:user_id]).to eq(123)
       end
     end
   end
 
-  context 'without a user' do
-    describe '#body' do
-      it 'populates with the unknown user' do
+  context "without a user" do
+    describe "#body" do
+      it "populates with the unknown user" do
         event = described_class.new(
           user_id: nil,
-          event_type: 'clicked on home'
+          event_type: "clicked on home"
         )
         expect(event.to_hash[:user_id]).to eq(AmplitudeAPI::USER_WITH_NO_ACCOUNT)
       end
     end
   end
 
-  describe 'init' do
-    context 'the user does not send in a price' do
-      it 'raises an error if the user sends in a product_id' do
+  describe "init" do
+    context "attributes" do
+      it "accepts string attributes" do
+        time = Time.at(1_451_606_400_000 / 1_000)
+        event = described_class.new(
+          "user_id" => 123,
+          "device_id" => "abcd",
+          "event_type" => "sausage",
+          "event_properties" => { "a" => "b" },
+          "user_properties" => { "c" => "d" },
+          "time" => time,
+          "ip" => "127.0.0.1",
+          "platform" => "Web",
+          "country" => "United States",
+          "insert_id" => "bestId"
+        )
+
+        expect(event.to_hash).to eq(event_type: "sausage",
+                                    user_id: 123,
+                                    device_id: "abcd",
+                                    event_properties: { "a" => "b" },
+                                    user_properties: { "c" => "d" },
+                                    time: 1_451_606_400_000,
+                                    ip: "127.0.0.1",
+                                    platform: "Web",
+                                    country: "United States",
+                                    insert_id: "bestId")
+      end
+
+      it "accepts symbol attributes" do
+        time = Time.at(1_451_606_400_000 / 1_000)
+        event = described_class.new(
+          user_id: 123,
+          device_id: "abcd",
+          event_type: "sausage",
+          event_properties: { "a" => "b" },
+          user_properties: { "c" => "d" },
+          time: time,
+          ip: "127.0.0.1",
+          platform: "Web",
+          country: "United States",
+          insert_id: "bestId"
+        )
+
+        expect(event.to_hash).to eq(event_type: "sausage",
+                                    user_id: 123,
+                                    device_id: "abcd",
+                                    event_properties: { "a" => "b" },
+                                    user_properties: { "c" => "d" },
+                                    time: 1_451_606_400_000,
+                                    ip: "127.0.0.1",
+                                    platform: "Web",
+                                    country: "United States",
+                                    insert_id: "bestId")
+      end
+    end
+
+    context "the user sends a revenue_type or a product_id" do
+      it "raises an error if there is not a price neither a revenue" do
+        expect do
+          described_class.new(
+            user_id: 123,
+            event_type: "bad event",
+            product_id: "hopscotch.4lyfe"
+          )
+        end.to raise_error ArgumentError, /You must provide a price or a revenue/
+
         expect do
           described_class.new(
             user_id: 123,
-            event_type: 'bad event',
-            product_id: 'hopscotch.4lyfe'
+            event_type: "bad event",
+            revenue_type: "whatever"
           )
-        end.to raise_error(ArgumentError)
+        end.to raise_error ArgumentError, /You must provide a price or a revenue/
       end
 
-      it 'raises an error if the user sends in a revenue_type' do
+      it "does not raise an error if there is a price" do
         expect do
           described_class.new(
             user_id: 123,
-            event_type: 'bad event',
-            revenue_type: 'tax return'
+            event_type: "bad event",
+            product_id: "hopscotch.4lyfe",
+            price: 10.2
           )
-        end.to raise_error(ArgumentError)
+        end.not_to raise_error
+
+        expect do
+          described_class.new(
+            user_id: 123,
+            event_type: "bad event",
+            revenue_type: "whatever",
+            price: 10.2
+          )
+        end.not_to raise_error
+      end
+
+      it "does not raise an error if there is a revenue" do
+        expect do
+          described_class.new(
+            user_id: 123,
+            event_type: "bad event",
+            product_id: "hopscotch.4lyfe",
+            revenue: 100.1
+          )
+        end.not_to raise_error
+
+        expect do
+          described_class.new(
+            user_id: 123,
+            event_type: "bad event",
+            revenue_type: "whatever",
+            revenue: 100.1
+          )
+        end.not_to raise_error
       end
     end
   end
 
-  describe '#body' do
-    it 'includes the event type' do
+  describe "#to_hash" do
+    it "includes the event type" do
       event = described_class.new(
         user_id: 123,
-        event_type: 'clicked on home'
+        event_type: "clicked on home"
       )
-      expect(event.to_hash[:event_type]).to eq('clicked on home')
+      expect(event.to_hash[:event_type]).to eq("clicked on home")
     end
 
-    it 'includes arbitrary properties' do
+    it "includes arbitrary properties" do
       event = described_class.new(
         user_id: 123,
-        event_type: 'clicked on home',
+        event_type: "clicked on home",
         event_properties: { abc: :def }
       )
       expect(event.to_hash[:event_properties]).to eq(abc: :def)
     end
 
-    describe 'time' do
-      it 'includes a time for the event' do
-        time = Time.parse('2016-01-01 00:00:00 -0000')
+    describe "time" do
+      it "includes a time for the event" do
+        time = Time.at(1_451_606_400_000 / 1_000)
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home',
+          event_type: "clicked on home",
           time: time
         )
         expect(event.to_hash[:time]).to eq(1_451_606_400_000)
       end
 
-      it 'does not include time if it is not set' do
+      it "does not include time if it is not set" do
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home'
+          event_type: "clicked on home"
         )
         expect(event.to_hash).not_to have_key(:time)
       end
     end
 
-    describe 'insert_id' do
-      it 'includes an insert_id for the event' do
+    describe "insert_id" do
+      it "includes an insert_id for the event" do
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home',
-          insert_id: 'foo-bar'
+          event_type: "clicked on home",
+          insert_id: "foo-bar"
         )
-        expect(event.to_hash[:insert_id]).to eq('foo-bar')
+        expect(event.to_hash[:insert_id]).to eq("foo-bar")
       end
 
-      it 'does not include insert_id if it is not set' do
+      it "does not include insert_id if it is not set" do
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home'
+          event_type: "clicked on home"
         )
         expect(event.to_hash).not_to have_key(:insert_id)
       end
     end
 
-    describe 'revenue params' do
-      it 'includes the price if it is set' do
-        price = 100_000.99
+    describe "platform" do
+      it "includes the platform for the event" do
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home',
-          price: price
+          event_type: "clicked on home",
+          platform: "Web"
         )
-        expect(event.to_hash[:price]).to eq(price)
+        expect(event.to_hash[:platform]).to eq("Web")
       end
 
-      it 'sets the quantity to 1 if the price is set and the quantity is not' do
+      it "does not include the platform if it is not set" do
+        event = described_class.new(
+          user_id: 123,
+          event_type: "clicked on home"
+        )
+        expect(event.to_hash).not_to have_key(:platform)
+      end
+    end
+
+    describe "country" do
+      it "includes the country for the event" do
+        event = described_class.new(
+          user_id: 123,
+          event_type: "clicked on home",
+          country: "United States"
+        )
+        expect(event.to_hash[:country]).to eq("United States")
+      end
+
+      it "does not include the country if it is not set" do
+        event = described_class.new(
+          user_id: 123,
+          event_type: "clicked on home"
+        )
+        expect(event.to_hash).not_to have_key(:country)
+      end
+    end
+
+    describe "revenue params" do
+      it "includes the price if it is set" do
         price = 100_000.99
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home',
+          event_type: "clicked on home",
           price: price
         )
-        expect(event.to_hash[:quantity]).to eq(1)
+        expect(event.to_hash[:price]).to eq(price)
       end
 
-      it 'includes the quantity if it is set' do
+      it "includes the quantity if it is set" do
         quantity = 100
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home',
+          event_type: "clicked on home",
           quantity: quantity,
           price: 10.99
         )
         expect(event.to_hash[:quantity]).to eq(quantity)
       end
 
-      it 'includes the productID if set' do
-        product_id = 'hopscotch.subscriptions.rule'
+      it "includes the revenue if it is set" do
+        revenue = 100
+        event = described_class.new(
+          user_id: 123,
+          event_type: "clicked on home",
+          quantity: 456,
+          revenue: revenue
+        )
+        expect(event.to_hash[:revenue]).to eq(revenue)
+      end
+
+      it "includes the productID if set" do
+        product_id = "hopscotch.subscriptions.rule"
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home',
+          event_type: "clicked on home",
           price: 199.99,
           product_id: product_id
         )
         expect(event.to_hash[:productId]).to eq(product_id)
       end
 
-      it 'includes the revenueType if set' do
-        revenue_type = 'income'
+      it "includes the revenueType if set" do
+        revenue_type = "income"
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home',
+          event_type: "clicked on home",
           price: 199.99,
           revenue_type: revenue_type
         )
         expect(event.to_hash[:revenueType]).to eq(revenue_type)
       end
 
-      it 'does not include revenue params if they are not set' do
+      it "does not include revenue params if they are not set" do
         event = described_class.new(
           user_id: 123,
-          event_type: 'clicked on home'
+          event_type: "clicked on home"
         )
         expect(event.to_hash).not_to have_key(:quantity)
         expect(event.to_hash).not_to have_key(:revenueType)
@@ -186,4 +321,44 @@ describe AmplitudeAPI::Event do
       end
     end
   end
+
+  describe "arbitrary properties" do
+    # We need to create a class for each test because the methods we are calling
+    # in this test group are modifying the class
+    let(:klass) { Class.new described_class }
+
+    let(:event) {
+      klass.new(
+        user_id: 123,
+        event_type: "bad event"
+      )
+    }
+
+    it "creates arbitrary properties when assigning values" do
+      event.arbitrary_property = "arbitrary value"
+
+      expect(event.arbitrary_property).to eq "arbitrary value"
+    end
+
+    it "responds_to? arbitrary properties" do
+      event.arbitrary_property = "arbitrary value"
+
+      expect(event.respond_to?(:arbitrary_property)).to be true
+      expect(event.respond_to?(:arbitrary_property=)).to be true
+    end
+
+    it "do not accepts blocks when assigning values to create properties" do
+      expect do
+        event.arbitrary_property { puts "whatever" }
+      end.to raise_error NoMethodError
+    end
+
+    it "includes arbitrary properties in the generated hash" do
+      event.arbitrary_property = "arbitrary value"
+
+      hash = event.to_hash
+
+      expect(hash).to include(arbitrary_property: "arbitrary value")
+    end
+  end
 end