amplitude-api 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67727755b54bfef1fc3ffa5889e11c7931420a13
-  data.tar.gz: 52feec8f51522d7f2c17b0db39d4e033f76efe2b
+  metadata.gz: 2613d299e9d407475b3a03eecb1633f0a5359b40
+  data.tar.gz: 7a48cebc3d4c592cb894c5d2bf9b814f0ff55a70
 SHA512:
-  metadata.gz: f3b3bf19725cda0082c7cf0acb7ca40614430a63ff5d929e803c3074955d9b35e5674987745a5fb17d2cc0e030fb7319a5903e012d40c98f5e171efea8f3b0f6
-  data.tar.gz: 09b6ca4ddb4ec2bdbed9980a41356b6f0096feace6819209c98ce37eb2a83722f509ca60762ccd7731a10308693bdce1eddf88f9e5cb27338fdf92be84dffd74
+  metadata.gz: 14739845274080c65ef0afb13b9547a91191ded8a935fae3a99bd04ffac16eb6f632fe4f83d4e209d3ef55f0dd3cd4eedfe645f030836423f42c530ac401363c
+  data.tar.gz: 1e6933e33ec4ae42076b57e8f9c6cc72797fb6cb25ce708f76182224f5fb02f4b4657fc00811e81211dcb23de1989879dda88ec4c5ec21ce98b96de9f1300fe3

data/lib/amplitude_api.rb

@@ -22,15 +22,17 @@ class AmplitudeAPI
     #
     # @param [ String ] event_name a string that describes the event, e.g. "clicked on Home"
     # @param [ String ] user a string or integer that uniquely identifies a user.
+    # @param [ String ] device a string that uniquely identifies the device.
     # @param [ Hash ] event_properties a hash that is serialized to JSON,
     # and can contain any other property to be stored on the Event
     # @param [ Hash ] user_properties a hash that is serialized to JSON,
     # and contains user properties to be associated with the user
     #
     # @return [ Typhoeus::Response ]
-    def send_event(event_name, user, options = {})
+    def send_event(event_name, user, device, options = {})
       event = AmplitudeAPI::Event.new(
         user_id: user,
+        device_id: device,
         event_type: event_name,
         event_properties: options.fetch(:event_properties, {}),
         user_properties: options.fetch(:user_properties, {})
@@ -72,8 +74,12 @@ class AmplitudeAPI
 
     # ==== Identification related methods
 
-    def send_identify(user_id, user_properties = {})
-      identification = AmplitudeAPI::Identification.new(user_id: user_id, user_properties: user_properties)
+    def send_identify(user_id, device_id, user_properties = {})
+      identification = AmplitudeAPI::Identification.new(
+        user_id: user_id,
+        device_id: device_id,
+        user_properties: user_properties
+      )
       identify(identification)
     end
 

data/lib/amplitude_api/event.rb

@@ -4,6 +4,9 @@ class AmplitudeAPI
     # @!attribute [ rw ] user_id
     #   @return [ String ] the user_id to be sent to Amplitude
     attr_accessor :user_id
+    # @!attribute [ rw ] device_id
+    #   @return [ String ] the device_id to be sent to Amplitude
+    attr_accessor :device_id
     # @!attribute [ rw ] event_type
     #   @return [ String ] the event_type to be sent to Amplitude
     attr_accessor :event_type
@@ -43,6 +46,7 @@ class AmplitudeAPI
     # Create a new Event
     #
     # @param [ String ] user_id a user_id to associate with the event
+    # @param [ String ] device_id a device_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)
@@ -52,15 +56,16 @@ class AmplitudeAPI
     # @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)
+    def initialize(attributes = {})
+      self.user_id = getopt(attributes, :user_id, '')
+      self.device_id = getopt(attributes, :device_id, nil)
+      self.event_type = getopt(attributes, :event_type, '')
+      self.event_properties = getopt(attributes, :event_properties, {})
+      self.user_properties = getopt(attributes, :user_properties, {})
+      self.time = getopt(attributes, :time)
+      self.ip = getopt(attributes, :ip, '')
+      self.insert_id = getopt(attributes, :insert_id)
+      validate_revenue_arguments(attributes)
     end
 
     def user_id=(value)
@@ -81,11 +86,17 @@ class AmplitudeAPI
       serialized_event[:user_id] = user_id
       serialized_event[:event_properties] = event_properties
       serialized_event[:user_properties] = user_properties
+      serialized_event = add_optional_properties(serialized_event)
+      serialized_event.merge(revenue_hash)
+    end
+
+    # @return [ Hash ] A serialized Event with optional properties
+    def add_optional_properties(serialized_event)
+      serialized_event[:device_id] = device_id if device_id
       serialized_event[:time] = formatted_time if time
       serialized_event[:ip] = ip if ip
       serialized_event[:insert_id] = insert_id if insert_id
-
-      serialized_event.merge(revenue_hash)
+      serialized_event
     end
 
     # @return [ true, false ]
@@ -106,10 +117,10 @@ class AmplitudeAPI
     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]
+      self.price = getopt(options, :price)
+      self.quantity = getopt(options, :quantity, 1) if price
+      self.product_id = getopt(options, :product_id)
+      self.revenue_type = getopt(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
@@ -123,5 +134,9 @@ class AmplitudeAPI
       revenue_hash[:price] = price if price
       revenue_hash
     end
+
+    def getopt(options, key, default = nil)
+      options.fetch(key.to_sym, options.fetch(key.to_s, default))
+    end
   end
 end

data/lib/amplitude_api/identification.rb

@@ -4,6 +4,9 @@ class AmplitudeAPI
     # @!attribute [ rw ] user_id
     #   @return [ String ] the user_id to be sent to Amplitude
     attr_accessor :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 +14,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 +38,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,3 @@
 class AmplitudeAPI
-  VERSION = '0.0.8'.freeze
+  VERSION = '0.0.9'.freeze
 end

data/readme.md

@@ -35,7 +35,6 @@ Currently, we are using this in Rails and using ActiveJob to dispatch events asy
 ## 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

data/spec/lib/amplitude_api/event_spec.rb

@@ -40,6 +40,54 @@ describe AmplitudeAPI::Event do
   end
 
   describe 'init' do
+    context 'attributes' do
+      it 'accepts string attributes' do
+        time = Time.parse('2016-01-01 00:00:00 -0000')
+        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',
+          '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',
+                                    insert_id: 'bestId')
+      end
+
+      it 'accepts symbol attributes' do
+        time = Time.parse('2016-01-01 00:00:00 -0000')
+        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',
+          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',
+                                    insert_id: 'bestId')
+      end
+    end
+
     context 'the user does not send in a price' do
       it 'raises an error if the user sends in a product_id' do
         expect do
@@ -63,7 +111,7 @@ describe AmplitudeAPI::Event do
     end
   end
 
-  describe '#body' do
+  describe '#to_hash' do
     it 'includes the event type' do
       event = described_class.new(
         user_id: 123,

data/spec/lib/amplitude_api/identification_spec.rb

@@ -36,6 +36,11 @@ describe AmplitudeAPI::Identification do
       expect(identification.to_hash[:user_id]).to eq(123)
     end
 
+    it 'includes the device id' do
+      identification = described_class.new(user_id: 123, device_id: 'abc')
+      expect(identification.to_hash[:device_id]).to eq('abc')
+    end
+
     it 'includes arbitrary user properties' do
       identification = described_class.new(
         user_id: 123,

data/spec/lib/amplitude_api_spec.rb

@@ -2,22 +2,58 @@ require 'spec_helper'
 
 describe AmplitudeAPI do
   let(:user) { Struct.new(:id).new(123) }
+  let(:device_id) { 'abcdef' }
 
   describe '.track' do
     context 'with a single event' do
-      it 'sends the event to Amplitude' do
-        event = AmplitudeAPI::Event.new(
-          user_id: 123,
-          event_type: 'clicked on sign up'
-        )
-        body = {
-          api_key: described_class.api_key,
-          event: JSON.generate([event.to_hash])
-        }
+      context 'with only user_id' do
+        it 'sends the event to Amplitude' do
+          event = AmplitudeAPI::Event.new(
+            user_id: 123,
+            event_type: 'clicked on sign up'
+          )
+          body = {
+            api_key: described_class.api_key,
+            event: JSON.generate([event.to_hash])
+          }
 
-        expect(Typhoeus).to receive(:post).with(AmplitudeAPI::TRACK_URI_STRING, body: body)
+          expect(Typhoeus).to receive(:post).with(AmplitudeAPI::TRACK_URI_STRING, body: body)
+
+          described_class.track(event)
+        end
+      end
+      context 'with only device_id' do
+        it 'sends the event to Amplitude' do
+          event = AmplitudeAPI::Event.new(
+            device_id: device_id,
+            event_type: 'clicked on sign up'
+          )
+          body = {
+            api_key: described_class.api_key,
+            event: JSON.generate([event.to_hash])
+          }
+
+          expect(Typhoeus).to receive(:post).with(AmplitudeAPI::TRACK_URI_STRING, body: body)
 
-        described_class.track(event)
+          described_class.track(event)
+        end
+      end
+      context 'with both user_id and device_id' do
+        it 'sends the event to Amplitude' do
+          event = AmplitudeAPI::Event.new(
+            user_id: 123,
+            device_id: device_id,
+            event_type: 'clicked on sign up'
+          )
+          body = {
+            api_key: described_class.api_key,
+            event: JSON.generate([event.to_hash])
+          }
+
+          expect(Typhoeus).to receive(:post).with(AmplitudeAPI::TRACK_URI_STRING, body: body)
+
+          described_class.track(event)
+        end
       end
     end
 
@@ -45,22 +81,63 @@ describe AmplitudeAPI do
 
   describe '.identify' do
     context 'with a single identification' do
-      it 'sends the identification to Amplitude' do
-        identification = AmplitudeAPI::Identification.new(
-          user_id: 123,
-          user_properties: {
-            first_name: 'John',
-            last_name: 'Doe'
+      context 'with only user_id' do
+        it 'sends the identification to Amplitude' do
+          identification = AmplitudeAPI::Identification.new(
+            user_id: 123,
+            user_properties: {
+              first_name: 'John',
+              last_name: 'Doe'
+            }
+          )
+          body = {
+            api_key: described_class.api_key,
+            identification: JSON.generate([identification.to_hash])
           }
-        )
-        body = {
-          api_key: described_class.api_key,
-          identification: JSON.generate([identification.to_hash])
-        }
 
-        expect(Typhoeus).to receive(:post).with(AmplitudeAPI::IDENTIFY_URI_STRING, body: body)
+          expect(Typhoeus).to receive(:post).with(AmplitudeAPI::IDENTIFY_URI_STRING, body: body)
+
+          described_class.identify(identification)
+        end
+      end
+      context 'with only device_id' do
+        it 'sends the identification to Amplitude' do
+          identification = AmplitudeAPI::Identification.new(
+            device_id: device_id,
+            user_properties: {
+              first_name: 'John',
+              last_name: 'Doe'
+            }
+          )
+          body = {
+            api_key: described_class.api_key,
+            identification: JSON.generate([identification.to_hash])
+          }
+
+          expect(Typhoeus).to receive(:post).with(AmplitudeAPI::IDENTIFY_URI_STRING, body: body)
+
+          described_class.identify(identification)
+        end
+      end
+      context 'with both user_id and device_id' do
+        it 'sends the identification to Amplitude' do
+          identification = AmplitudeAPI::Identification.new(
+            user_id: 123,
+            device_id: device_id,
+            user_properties: {
+              first_name: 'John',
+              last_name: 'Doe'
+            }
+          )
+          body = {
+            api_key: described_class.api_key,
+            identification: JSON.generate([identification.to_hash])
+          }
+
+          expect(Typhoeus).to receive(:post).with(AmplitudeAPI::IDENTIFY_URI_STRING, body: body)
 
-        described_class.identify(identification)
+          described_class.identify(identification)
+        end
       end
     end
 
@@ -74,7 +151,7 @@ describe AmplitudeAPI do
           }
         )
         identification2 = AmplitudeAPI::Identification.new(
-          user_id: 456,
+          device_id: 456,
           user_properties: {
             first_name: 'John',
             last_name: 'Doe'
@@ -121,82 +198,120 @@ describe AmplitudeAPI do
         ip: '8.8.8.8'
       )
     end
-  end
-
-  describe '.send_event' do
-    it 'sends an event to AmplitudeAPI' do
+    it 'initializes event with parameter including device_id' do
       event = AmplitudeAPI::Event.new(
-        user_id: user,
+        user_id: 123,
+        device_id: 'abc',
         event_type: 'test_event',
-        event_properties: { test_property: 1 }
+        event_properties: {
+          test_property: 1
+        },
+        ip: '8.8.8.8'
+      )
+      expect(event.to_hash).to eq(
+        event_type: 'test_event',
+        user_id: 123,
+        device_id: 'abc',
+        event_properties: { test_property: 1 },
+        user_properties: {},
+        ip: '8.8.8.8'
       )
-      expect(described_class).to receive(:track).with(event)
-
-      described_class.send_event('test_event', user, event_properties: { test_property: 1 })
     end
+  end
 
-    context 'the user is nil' do
-      it 'sends an event with the no account user' do
+  describe '.send_event' do
+    context 'with only user_id' do
+      it 'sends an event to AmplitudeAPI' do
         event = AmplitudeAPI::Event.new(
-          user_id: nil,
+          user_id: user,
           event_type: 'test_event',
           event_properties: { test_property: 1 }
         )
         expect(described_class).to receive(:track).with(event)
 
-        described_class.send_event('test_event', nil, event_properties: { test_property: 1 })
+        described_class.send_event('test_event', user, nil, event_properties: { test_property: 1 })
       end
-    end
 
-    context 'the user is a user_id' do
-      it 'sends an event to AmplitudeAPI' do
-        event = AmplitudeAPI::Event.new(
-          user_id: 123,
-          event_type: 'test_event',
-          event_properties: { test_property: 1 }
-        )
-        expect(described_class).to receive(:track).with(event)
+      context 'the user is nil' do
+        it 'sends an event with the no account user' do
+          event = AmplitudeAPI::Event.new(
+            user_id: nil,
+            event_type: 'test_event',
+            event_properties: { test_property: 1 }
+          )
+          expect(described_class).to receive(:track).with(event)
 
-        described_class.send_event('test_event', user.id, event_properties: { test_property: 1 })
+          described_class.send_event('test_event', nil, nil, event_properties: { test_property: 1 })
+        end
       end
 
-      it 'sends arbitrary user_properties to AmplitudeAPI' do
-        event = AmplitudeAPI::Event.new(
-          user_id: 123,
-          event_type: 'test_event',
-          event_properties: { test_property: 1 },
-          user_properties: { test_user_property: 'abc' }
-        )
-        expect(described_class).to receive(:track).with(event)
+      context 'the user is a user_id' do
+        it 'sends an event to AmplitudeAPI' do
+          event = AmplitudeAPI::Event.new(
+            user_id: 123,
+            event_type: 'test_event',
+            event_properties: { test_property: 1 }
+          )
+          expect(described_class).to receive(:track).with(event)
 
-        described_class.send_event(
-          'test_event',
-          user.id,
-          event_properties: { test_property: 1 },
-          user_properties: { test_user_property: 'abc' }
-        )
+          described_class.send_event('test_event', user.id, nil, event_properties: { test_property: 1 })
+        end
+
+        it 'sends arbitrary user_properties to AmplitudeAPI' do
+          event = AmplitudeAPI::Event.new(
+            user_id: 123,
+            event_type: 'test_event',
+            event_properties: { test_property: 1 },
+            user_properties: { test_user_property: 'abc' }
+          )
+          expect(described_class).to receive(:track).with(event)
+
+          described_class.send_event(
+            'test_event',
+            user.id,
+            nil,
+            event_properties: { test_property: 1 },
+            user_properties: { test_user_property: 'abc' }
+          )
+        end
       end
     end
-  end
+    context 'with device_id' do
+      context 'the user is not nil' do
+        it 'sends an event to AmplitudeAPI' do
+          event = AmplitudeAPI::Event.new(
+            user_id: user,
+            device_id: device_id,
+            event_type: 'test_event',
+            event_properties: { test_property: 1 }
+          )
+          expect(described_class).to receive(:track).with(event)
 
-  describe '.send_identify' do
-    it 'sends an identify to AmplitudeAPI' do
-      identification = AmplitudeAPI::Identification.new(
-        user_id: user,
-        user_properties: {
-          first_name: 'John',
-          last_name: 'Doe'
-        }
-      )
-      expect(described_class).to receive(:identify).with(identification)
+          described_class.send_event('test_event', user, device_id, event_properties: { test_property: 1 })
+        end
+      end
+
+      context 'the user is nil' do
+        it 'sends an event with the no account user' do
+          event = AmplitudeAPI::Event.new(
+            user_id: nil,
+            device_id: device_id,
+            event_type: 'test_event',
+            event_properties: { test_property: 1 }
+          )
+          expect(described_class).to receive(:track).with(event)
 
-      described_class.send_identify(user, first_name: 'John', last_name: 'Doe')
+          described_class.send_event('test_event', nil, device_id, event_properties: { test_property: 1 })
+        end
+      end
     end
+  end
 
-    context 'the user is nil' do
-      it 'sends an identify with the no account user' do
+  describe '.send_identify' do
+    context 'with no device_id' do
+      it 'sends an identify to AmplitudeAPI' do
         identification = AmplitudeAPI::Identification.new(
-          user_id: nil,
+          user_id: user,
           user_properties: {
             first_name: 'John',
             last_name: 'Doe'
@@ -204,14 +319,44 @@ describe AmplitudeAPI do
         )
         expect(described_class).to receive(:identify).with(identification)
 
-        described_class.send_identify(nil, first_name: 'John', last_name: 'Doe')
+        described_class.send_identify(user, nil, first_name: 'John', last_name: 'Doe')
+      end
+
+      context 'the user is nil' do
+        it 'sends an identify with the no account user' do
+          identification = AmplitudeAPI::Identification.new(
+            user_id: nil,
+            user_properties: {
+              first_name: 'John',
+              last_name: 'Doe'
+            }
+          )
+          expect(described_class).to receive(:identify).with(identification)
+
+          described_class.send_identify(nil, nil, first_name: 'John', last_name: 'Doe')
+        end
       end
-    end
 
-    context 'the user is a user_id' do
+      context 'the user is a user_id' do
+        it 'sends an identify to AmplitudeAPI' do
+          identification = AmplitudeAPI::Identification.new(
+            user_id: 123,
+            user_properties: {
+              first_name: 'John',
+              last_name: 'Doe'
+            }
+          )
+          expect(described_class).to receive(:identify).with(identification)
+
+          described_class.send_identify(user.id, nil, first_name: 'John', last_name: 'Doe')
+        end
+      end
+    end
+    context 'with a device_id' do
       it 'sends an identify to AmplitudeAPI' do
         identification = AmplitudeAPI::Identification.new(
-          user_id: 123,
+          user_id: user,
+          device_id: 'abc',
           user_properties: {
             first_name: 'John',
             last_name: 'Doe'
@@ -219,7 +364,7 @@ describe AmplitudeAPI do
         )
         expect(described_class).to receive(:identify).with(identification)
 
-        described_class.send_identify(user.id, first_name: 'John', last_name: 'Doe')
+        described_class.send_identify(user, 'abc', first_name: 'John', last_name: 'Doe')
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: amplitude-api
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Alex Rakoczy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-21 00:00:00.000000000 Z
+date: 2016-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -125,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.6
 signing_key: 
 specification_version: 4
 summary: Send events to the Amplitude API