analytics-ruby 2.2.5 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f217e8929c1705f8602e90bdd0f23b2e77fdb97aa57c530e7ae325005a640258
-  data.tar.gz: 2a5674bf8575c46c472622cd2c2974a0f110215edb76dbce90126f1e62b43a99
+  metadata.gz: 51f3f02afed05c9c8461b454e0a3067962a75b8efde0930db0098eebf4a62829
+  data.tar.gz: e7d486d6c6186535e9a005c4d950e6e29d2dd9937f9b6da625191d786f76846a
 SHA512:
-  metadata.gz: 5a118f808ca6a2fb9235ac9464665b618213e0e8ff372e001d4243da059e8cd4b5c2f8fbbac0c1eb8590f637c2d6594d5a5624183f11ba54355dc52769e8177c
-  data.tar.gz: 1ab60c691e8422bb33b7e14b1803cab36e457056871c366dabc1143289fede5e174c812dbca492176189f79a33419b1d2d3ea90ea61f827bd0e7248bef61cc95
+  metadata.gz: c2ce09d450de65620eb99f9fae86aa5ce57709d53aa4a93c73c2d3db0b173afad532383a50fe4dcb953df72171b731a263ff7308aed79b646a25bc202c555e4d
+  data.tar.gz: b3625484ebca6117ae79fc42f03a595dff861b8c5ca02a6ef12ea9e933229c1479dad40b4db1d85e61ddf585c7c5a072d68e9cd21ced6b2482db338f45073707

data/bin/analytics

@@ -29,6 +29,7 @@ command :send do |c|
   c.option '--userId=<userId>', String, 'the user id to send the event as'
   c.option '--anonymousId=<anonymousId>', String, 'the anonymous user id to send the event as'
   c.option '--context=<context>', 'additional context for the event (JSON-encoded)'
+  c.option '--integrations=<integrations>', 'additional integrations for the event (JSON-encoded)'
 
   c.option '--event=<event>', String, 'the event name to send with the event'
   c.option '--properties=<properties>', 'the event properties to send (JSON-encoded)'
@@ -38,6 +39,7 @@ command :send do |c|
   c.option '--traits=<traits>', 'the identify/group traits to send (JSON-encoded)'
 
   c.option '--groupId=<groupId>', String, 'the group id'
+  c.option '--previousId=<previousId>', String, 'the previous id'
 
   c.action do |args, options|
     Analytics = Segment::Analytics.new({
@@ -52,7 +54,8 @@ command :send do |c|
         event: options.event,
         anonymous_id: options.anonymousId,
         properties: json_hash(options.properties),
-        context: json_hash(options.context)
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
       })
     when "page"
       Analytics.page({
@@ -60,22 +63,25 @@ command :send do |c|
         anonymous_id: options.anonymousId,
         name: options.name,
         properties: json_hash(options.properties),
-        context: json_hash(options.context)
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
       })
     when "screen"
       Analytics.screen({
         user_id: options.userId,
         anonymous_id: options.anonymousId,
-        name: option.name,
-        traits: json_hash(options.traits),
-        properties: json_hash(option.properties)
+        name: options.name,
+        properties: json_hash(options.properties),
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
       })
     when "identify"
       Analytics.identify({
         user_id: options.userId,
         anonymous_id: options.anonymousId,
         traits: json_hash(options.traits),
-        context: json_hash(options.context)
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
       })
     when "group"
       Analytics.group({
@@ -83,7 +89,16 @@ command :send do |c|
         anonymous_id: options.anonymousId,
         group_id: options.groupId,
         traits: json_hash(options.traits),
-        context: json_hash(options.context)
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
+      })
+    when "alias"
+      Analytics.alias({
+        previous_id: options.previousId,
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
       })
     else
       raise "Invalid Message Type #{options.type}"

data/lib/segment/analytics/client.rb

@@ -21,11 +21,12 @@ module Segment
         symbolize_keys!(opts)
 
         @queue = Queue.new
+        @test = opts[:test]
         @write_key = opts[:write_key]
         @max_queue_size = opts[:max_queue_size] || Defaults::Queue::MAX_SIZE
-        @options = opts
         @worker_mutex = Mutex.new
-        @worker = Worker.new(@queue, @write_key, @options)
+        @worker = Worker.new(@queue, @write_key, opts)
+        @worker_thread = nil
 
         check_write_key!
 
@@ -43,58 +44,32 @@ module Segment
         end
       end
 
+      # @!macro common_attrs
+      #   @option attrs [String] :anonymous_id ID for a user when you don't know
+      #     who they are yet. (optional but you must provide either an
+      #     `anonymous_id` or `user_id`)
+      #   @option attrs [Hash] :context ({})
+      #   @option attrs [Hash] :integrations What integrations this event
+      #     goes to (optional)
+      #   @option attrs [String] :message_id ID that uniquely
+      #     identifies a message across the API. (optional)
+      #   @option attrs [Time] :timestamp When the event occurred (optional)
+      #   @option attrs [String] :user_id The ID for this user in your database
+      #     (optional but you must provide either an `anonymous_id` or `user_id`)
+      #   @option attrs [Hash] :options Options such as user traits (optional)
+
       # Tracks an event
       #
       # @see https://segment.com/docs/sources/server/ruby/#track
       #
       # @param [Hash] attrs
-      # @option attrs [String] :anonymous_id ID for a user when you don't know
-      #   who they are yet. (optional but you must provide either an
-      #   `anonymous_id` or `user_id`)
-      # @option attrs [Hash] :context ({})
+      #
       # @option attrs [String] :event Event name
-      # @option attrs [Hash] :integrations What integrations this event
-      #   goes to (optional)
-      # @option attrs [Hash] :options Options such as user traits (optional)
       # @option attrs [Hash] :properties Event properties (optional)
-      # @option attrs [Time] :timestamp When the event occurred (optional)
-      # @option attrs [String] :user_id The ID for this user in your database
-      #   (optional but you must provide either an `anonymous_id` or `user_id`)
-      # @option attrs [String] :message_id ID that uniquely
-      #   identifies a message across the API. (optional)
+      # @macro common_attrs
       def track(attrs)
         symbolize_keys! attrs
-        check_user_id! attrs
-
-        event = attrs[:event]
-        properties = attrs[:properties] || {}
-        timestamp = attrs[:timestamp] || Time.new
-        context = attrs[:context] || {}
-        message_id = attrs[:message_id].to_s if attrs[:message_id]
-
-        check_timestamp! timestamp
-
-        if event.nil? || event.empty?
-          raise ArgumentError, 'Must supply event as a non-empty string'
-        end
-
-        raise ArgumentError, 'Properties must be a Hash' unless properties.is_a? Hash
-        isoify_dates! properties
-
-        add_context context
-
-        enqueue({
-          :event => event,
-          :userId => attrs[:user_id],
-          :anonymousId => attrs[:anonymous_id],
-          :context => context,
-          :options => attrs[:options],
-          :integrations => attrs[:integrations],
-          :properties => properties,
-          :messageId => message_id,
-          :timestamp => datetime_in_iso8601(timestamp),
-          :type => 'track'
-        })
+        enqueue(FieldParser.parse_for_track(attrs))
       end
 
       # Identifies a user
@@ -102,46 +77,12 @@ module Segment
       # @see https://segment.com/docs/sources/server/ruby/#identify
       #
       # @param [Hash] attrs
-      # @option attrs [String] :anonymous_id ID for a user when you don't know
-      #   who they are yet. (optional but you must provide either an
-      #   `anonymous_id` or `user_id`)
-      # @option attrs [Hash] :context ({})
-      # @option attrs [Hash] :integrations What integrations this event
-      #   goes to (optional)
-      # @option attrs [Hash] :options Options such as user traits (optional)
-      # @option attrs [Time] :timestamp When the event occurred (optional)
+      #
       # @option attrs [Hash] :traits User traits (optional)
-      # @option attrs [String] :user_id The ID for this user in your database
-      #   (optional but you must provide either an `anonymous_id` or `user_id`)
-      # @option attrs [String] :message_id ID that uniquely identifies a
-      #   message across the API. (optional)
+      # @macro common_attrs
       def identify(attrs)
         symbolize_keys! attrs
-        check_user_id! attrs
-
-        traits = attrs[:traits] || {}
-        timestamp = attrs[:timestamp] || Time.new
-        context = attrs[:context] || {}
-        message_id = attrs[:message_id].to_s if attrs[:message_id]
-
-        check_timestamp! timestamp
-
-        raise ArgumentError, 'Must supply traits as a hash' unless traits.is_a? Hash
-        isoify_dates! traits
-
-        add_context context
-
-        enqueue({
-          :userId => attrs[:user_id],
-          :anonymousId => attrs[:anonymous_id],
-          :integrations => attrs[:integrations],
-          :context => context,
-          :traits => traits,
-          :options => attrs[:options],
-          :messageId => message_id,
-          :timestamp => datetime_in_iso8601(timestamp),
-          :type => 'identify'
-        })
+        enqueue(FieldParser.parse_for_identify(attrs))
       end
 
       # Aliases a user from one id to another
@@ -149,39 +90,12 @@ module Segment
       # @see https://segment.com/docs/sources/server/ruby/#alias
       #
       # @param [Hash] attrs
-      # @option attrs [Hash] :context ({})
-      # @option attrs [Hash] :integrations What integrations this must be
-      #   sent to (optional)
-      # @option attrs [Hash] :options Options such as user traits (optional)
+      #
       # @option attrs [String] :previous_id The ID to alias from
-      # @option attrs [Time] :timestamp When the alias occurred (optional)
-      # @option attrs [String] :user_id The ID to alias to
-      # @option attrs [String] :message_id ID that uniquely identifies a
-      #   message across the API. (optional)
+      # @macro common_attrs
       def alias(attrs)
         symbolize_keys! attrs
-
-        from = attrs[:previous_id]
-        to = attrs[:user_id]
-        timestamp = attrs[:timestamp] || Time.new
-        context = attrs[:context] || {}
-        message_id = attrs[:message_id].to_s if attrs[:message_id]
-
-        check_presence! from, 'previous_id'
-        check_presence! to, 'user_id'
-        check_timestamp! timestamp
-        add_context context
-
-        enqueue({
-          :previousId => from,
-          :userId => to,
-          :integrations => attrs[:integrations],
-          :context => context,
-          :options => attrs[:options],
-          :messageId => message_id,
-          :timestamp => datetime_in_iso8601(timestamp),
-          :type => 'alias'
-        })
+        enqueue(FieldParser.parse_for_alias(attrs))
       end
 
       # Associates a user identity with a group.
@@ -189,48 +103,13 @@ module Segment
       # @see https://segment.com/docs/sources/server/ruby/#group
       #
       # @param [Hash] attrs
-      # @option attrs [String] :anonymous_id ID for a user when you don't know
-      #   who they are yet. (optional but you must provide either an
-      #   `anonymous_id` or `user_id`)
-      # @option attrs [Hash] :context ({})
+      #
       # @option attrs [String] :group_id The ID of the group
-      # @option attrs [Hash] :integrations What integrations this event
-      #   goes to (optional)
-      # @option attrs [Hash] :options Options such as user traits (optional)
-      # @option attrs [Time] :timestamp When the event occurred (optional)
-      # @option attrs [String] :user_id The ID for the user that is part of
-      #   the group
-      # @option attrs [String] :message_id ID that uniquely identifies a
-      #   message across the API. (optional)
+      # @option attrs [Hash] :traits User traits (optional)
+      # @macro common_attrs
       def group(attrs)
         symbolize_keys! attrs
-        check_user_id! attrs
-
-        group_id = attrs[:group_id]
-        user_id = attrs[:user_id]
-        traits = attrs[:traits] || {}
-        timestamp = attrs[:timestamp] || Time.new
-        context = attrs[:context] || {}
-        message_id = attrs[:message_id].to_s if attrs[:message_id]
-
-        raise ArgumentError, '.traits must be a hash' unless traits.is_a? Hash
-        isoify_dates! traits
-
-        check_presence! group_id, 'group_id'
-        check_timestamp! timestamp
-        add_context context
-
-        enqueue({
-          :groupId => group_id,
-          :userId => user_id,
-          :traits => traits,
-          :integrations => attrs[:integrations],
-          :options => attrs[:options],
-          :context => context,
-          :messageId => message_id,
-          :timestamp => datetime_in_iso8601(timestamp),
-          :type => 'group'
-        })
+        enqueue(FieldParser.parse_for_group(attrs))
       end
 
       # Records a page view
@@ -238,97 +117,26 @@ module Segment
       # @see https://segment.com/docs/sources/server/ruby/#page
       #
       # @param [Hash] attrs
-      # @option attrs [String] :anonymous_id ID for a user when you don't know
-      #   who they are yet. (optional but you must provide either an
-      #   `anonymous_id` or `user_id`)
-      # @option attrs [String] :category The page category (optional)
-      # @option attrs [Hash] :context ({})
-      # @option attrs [Hash] :integrations What integrations this event
-      #   goes to (optional)
+      #
       # @option attrs [String] :name Name of the page
-      # @option attrs [Hash] :options Options such as user traits (optional)
       # @option attrs [Hash] :properties Page properties (optional)
-      # @option attrs [Time] :timestamp When the pageview occurred (optional)
-      # @option attrs [String] :user_id The ID of the user viewing the page
-      # @option attrs [String] :message_id ID that uniquely identifies a
-      #   message across the API. (optional)
+      # @macro common_attrs
       def page(attrs)
         symbolize_keys! attrs
-        check_user_id! attrs
-
-        name = attrs[:name].to_s
-        properties = attrs[:properties] || {}
-        timestamp = attrs[:timestamp] || Time.new
-        context = attrs[:context] || {}
-        message_id = attrs[:message_id].to_s if attrs[:message_id]
-
-        raise ArgumentError, '.properties must be a hash' unless properties.is_a? Hash
-        isoify_dates! properties
-
-        check_timestamp! timestamp
-        add_context context
-
-        enqueue({
-          :userId => attrs[:user_id],
-          :anonymousId => attrs[:anonymous_id],
-          :name => name,
-          :category => attrs[:category],
-          :properties => properties,
-          :integrations => attrs[:integrations],
-          :options => attrs[:options],
-          :context => context,
-          :messageId => message_id,
-          :timestamp => datetime_in_iso8601(timestamp),
-          :type => 'page'
-        })
+        enqueue(FieldParser.parse_for_page(attrs))
       end
 
       # Records a screen view (for a mobile app)
       #
       # @param [Hash] attrs
-      # @option attrs [String] :anonymous_id ID for a user when you don't know
-      #   who they are yet. (optional but you must provide either an
-      #   `anonymous_id` or `user_id`)
-      # @option attrs [String] :category The screen category (optional)
-      # @option attrs [Hash] :context ({})
-      # @option attrs [Hash] :integrations What integrations this event
-      #   goes to (optional)
+      #
       # @option attrs [String] :name Name of the screen
-      # @option attrs [Hash] :options Options such as user traits (optional)
-      # @option attrs [Hash] :properties Page properties (optional)
-      # @option attrs [Time] :timestamp When the pageview occurred (optional)
-      # @option attrs [String] :user_id The ID of the user viewing the screen
-      # @option attrs [String] :message_id ID that uniquely identifies a
-      #   message across the API. (optional)
+      # @option attrs [Hash] :properties Screen properties (optional)
+      # @option attrs [String] :category The screen category (optional)
+      # @macro common_attrs
       def screen(attrs)
         symbolize_keys! attrs
-        check_user_id! attrs
-
-        name = attrs[:name].to_s
-        properties = attrs[:properties] || {}
-        timestamp = attrs[:timestamp] || Time.new
-        context = attrs[:context] || {}
-        message_id = attrs[:message_id].to_s if attrs[:message_id]
-
-        raise ArgumentError, '.properties must be a hash' unless properties.is_a? Hash
-        isoify_dates! properties
-
-        check_timestamp! timestamp
-        add_context context
-
-        enqueue({
-          :userId => attrs[:user_id],
-          :anonymousId => attrs[:anonymous_id],
-          :name => name,
-          :properties => properties,
-          :category => attrs[:category],
-          :options => attrs[:options],
-          :integrations => attrs[:integrations],
-          :context => context,
-          :messageId => message_id,
-          :timestamp => timestamp.iso8601,
-          :type => 'screen'
-        })
+        enqueue(FieldParser.parse_for_screen(attrs))
       end
 
       # @return [Fixnum] number of messages in the queue
@@ -336,6 +144,14 @@ module Segment
         @queue.length
       end
 
+      def test_queue
+        unless @test
+          raise 'Test queue only available when setting :test to true.'
+        end
+
+        @test_queue ||= TestQueue.new
+      end
+
       private
 
       # private: Enqueues the action.
@@ -345,6 +161,8 @@ module Segment
         # add our request id for tracing purposes
         action[:messageId] ||= uid
 
+        test_queue << action if @test
+
         if @queue.length < @max_queue_size
           @queue << action
           ensure_worker_running
@@ -360,53 +178,11 @@ module Segment
         end
       end
 
-      # private: Ensures that a string is non-empty
-      #
-      # obj    - String|Number that must be non-blank
-      # name   - Name of the validated value
-      #
-      def check_presence!(obj, name)
-        if obj.nil? || (obj.is_a?(String) && obj.empty?)
-          raise ArgumentError, "#{name} must be given"
-        end
-      end
-
-      # private: Adds contextual information to the call
-      #
-      # context - Hash of call context
-      def add_context(context)
-        context[:library] = { :name => 'analytics-ruby', :version => Segment::Analytics::VERSION.to_s }
-      end
-
       # private: Checks that the write_key is properly initialized
       def check_write_key!
         raise ArgumentError, 'Write key must be initialized' if @write_key.nil?
       end
 
-      # private: Checks the timstamp option to make sure it is a Time.
-      def check_timestamp!(timestamp)
-        raise ArgumentError, 'Timestamp must be a Time' unless timestamp.is_a? Time
-      end
-
-      def event(attrs)
-        symbolize_keys! attrs
-
-        {
-          :userId => user_id,
-          :name => name,
-          :properties => properties,
-          :context => context,
-          :timestamp => datetime_in_iso8601(timestamp),
-          :type => 'screen'
-        }
-      end
-
-      def check_user_id!(attrs)
-        unless attrs[:user_id] || attrs[:anonymous_id]
-          raise ArgumentError, 'Must supply either user_id or anonymous_id'
-        end
-      end
-
       def ensure_worker_running
         return if worker_running?
         @worker_mutex.synchronize do

data/lib/segment/analytics/field_parser.rb

@@ -0,0 +1,192 @@
+module Segment
+  class Analytics
+    # Handles parsing fields according to the Segment Spec
+    #
+    # @see https://segment.com/docs/spec/
+    class FieldParser
+      class << self
+        include Segment::Analytics::Utils
+
+        # In addition to the common fields, track accepts:
+        #
+        # - "event"
+        # - "properties"
+        def parse_for_track(fields)
+          common = parse_common_fields(fields)
+
+          event = fields[:event]
+          properties = fields[:properties] || {}
+
+          check_presence!(event, 'event')
+          check_is_hash!(properties, 'properties')
+
+          isoify_dates! properties
+
+          common.merge({
+            :type => 'track',
+            :event => event.to_s,
+            :properties => properties
+          })
+        end
+
+        # In addition to the common fields, identify accepts:
+        #
+        # - "traits"
+        def parse_for_identify(fields)
+          common = parse_common_fields(fields)
+
+          traits = fields[:traits] || {}
+          check_is_hash!(traits, 'traits')
+          isoify_dates! traits
+
+          common.merge({
+            :type => 'identify',
+            :traits => traits
+          })
+        end
+
+        # In addition to the common fields, alias accepts:
+        #
+        # - "previous_id"
+        def parse_for_alias(fields)
+          common = parse_common_fields(fields)
+
+          previous_id = fields[:previous_id]
+          check_presence!(previous_id, 'previous_id')
+
+          common.merge({
+            :type => 'alias',
+            :previousId => previous_id
+          })
+        end
+
+        # In addition to the common fields, group accepts:
+        #
+        # - "group_id"
+        # - "traits"
+        def parse_for_group(fields)
+          common = parse_common_fields(fields)
+
+          group_id = fields[:group_id]
+          traits = fields[:traits] || {}
+
+          check_presence!(group_id, 'group_id')
+          check_is_hash!(traits, 'traits')
+
+          isoify_dates! traits
+
+          common.merge({
+            :type => 'group',
+            :groupId => group_id,
+            :traits => traits
+          })
+        end
+
+        # In addition to the common fields, page accepts:
+        #
+        # - "name"
+        # - "properties"
+        def parse_for_page(fields)
+          common = parse_common_fields(fields)
+
+          name = fields[:name] || ''
+          properties = fields[:properties] || {}
+
+          check_is_hash!(properties, 'properties')
+
+          isoify_dates! properties
+
+          common.merge({
+            :type => 'page',
+            :name => name.to_s,
+            :properties => properties
+          })
+        end
+
+        # In addition to the common fields, screen accepts:
+        #
+        # - "name"
+        # - "properties"
+        # - "category" (Not in spec, retained for backward compatibility"
+        def parse_for_screen(fields)
+          common = parse_common_fields(fields)
+
+          name = fields[:name]
+          properties = fields[:properties] || {}
+          category = fields[:category]
+
+          check_presence!(name, 'name')
+          check_is_hash!(properties, 'properties')
+
+          isoify_dates! properties
+
+          parsed = common.merge({
+            :type => 'screen',
+            :name => name,
+            :properties => properties
+          })
+
+          parsed[:category] = category if category
+
+          parsed
+        end
+
+        private
+
+        def parse_common_fields(fields)
+          timestamp = fields[:timestamp] || Time.new
+          message_id = fields[:message_id].to_s if fields[:message_id]
+          context = fields[:context] || {}
+
+          check_user_id! fields
+          check_timestamp! timestamp
+
+          add_context! context
+
+          parsed = {
+            :context => context,
+            :messageId => message_id,
+            :timestamp => datetime_in_iso8601(timestamp)
+          }
+
+          parsed[:userId] = fields[:user_id] if fields[:user_id]
+          parsed[:anonymousId] = fields[:anonymous_id] if fields[:anonymous_id]
+          parsed[:integrations] = fields[:integrations] if fields[:integrations]
+
+          # Not in spec, retained for backward compatibility
+          parsed[:options] = fields[:options] if fields[:options]
+
+          parsed
+        end
+
+        def check_user_id!(fields)
+          unless fields[:user_id] || fields[:anonymous_id]
+            raise ArgumentError, 'Must supply either user_id or anonymous_id'
+          end
+        end
+
+        def check_timestamp!(timestamp)
+          raise ArgumentError, 'Timestamp must be a Time' unless timestamp.is_a? Time
+        end
+
+        def add_context!(context)
+          context[:library] = { :name => 'analytics-ruby', :version => Segment::Analytics::VERSION.to_s }
+        end
+
+        # private: Ensures that a string is non-empty
+        #
+        # obj    - String|Number that must be non-blank
+        # name   - Name of the validated value
+        def check_presence!(obj, name)
+          if obj.nil? || (obj.is_a?(String) && obj.empty?)
+            raise ArgumentError, "#{name} must be given"
+          end
+        end
+
+        def check_is_hash!(obj, name)
+          raise ArgumentError, "#{name} must be a Hash" unless obj.is_a? Hash
+        end
+      end
+    end
+  end
+end