analytics-ruby 2.2.6 → 2.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 472dcf42eeb6b9d83166a526ebeb81bfbbdc74a429511776fedac53ae585da27
-  data.tar.gz: 70d5bfbf53332c3899cb4cc0071a068c25da7fabee8e934ced0d335bbb08c45f
+  metadata.gz: 6c8742471c22e19783a69dee3403ddbd1ac2785b7bbd9608840432e34f4d50a5
+  data.tar.gz: dad6dfe750ebf0746e2228cd29551afc23e4ce38d40c7df00184994e6d16db8b
 SHA512:
-  metadata.gz: 112f00cdfb0e27ab41ae0c74ebe76d8fba6777acd71ec0a46fc6576948f65a096668c59354393ef600f961631f6cf1938bde3bcbb4ff09aafd4fcf1ed73a2aa9
-  data.tar.gz: 4af5e31b75e80dd20dacf7d3e5aeb58ce2e1280337dbe82b69b63c1588ba650d774a9625f00f930b0a25df612f8d7654ae16947cd5b3369ce6e6e3b4880e6483
+  metadata.gz: c5d305d7a968088a3ef5488faa360ce06ad6d97072bde0d6b068aae11bcb1824814f87fe1a18e8f09a231cbe34be2954b4565605cdb8a6b8e0d370ee56a6b492
+  data.tar.gz: 154b45294bff8f12f2dd8bc338742889d11017983f5e516cca36e9446bbb3c0e6aa61ac35252aaf20ba39ececa96a58c264990f9a1dece39d6d5b39435ab1ad3

data/lib/segment/analytics.rb

@@ -1,6 +1,7 @@
 require 'segment/analytics/version'
 require 'segment/analytics/defaults'
 require 'segment/analytics/utils'
+require 'segment/analytics/field_parser'
 require 'segment/analytics/client'
 require 'segment/analytics/worker'
 require 'segment/analytics/request'

data/lib/segment/analytics/client.rb

@@ -23,9 +23,8 @@ module Segment
         @queue = Queue.new
         @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)
 
         check_write_key!
 
@@ -43,58 +42,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 +75,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 +88,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 +101,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 +115,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
@@ -360,53 +166,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,184 @@
+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
+
+          common.merge({
+            :type => 'screen',
+            :name => name,
+            :properties => properties,
+            :category => category
+          })
+        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
+
+          {
+            :anonymousId => fields[:anonymous_id],
+            :context => context,
+            :integrations => fields[:integrations],
+            :messageId => message_id,
+            :timestamp => datetime_in_iso8601(timestamp),
+            :userId => fields[:user_id],
+            :options => fields[:options] # Not in spec, retained for backward compatibility
+          }
+        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

data/lib/segment/analytics/version.rb

@@ -1,5 +1,5 @@
 module Segment
   class Analytics
-    VERSION = '2.2.6'
+    VERSION = '2.2.7'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: analytics-ruby
 version: !ruby/object:Gem::Version
-  version: 2.2.6
+  version: 2.2.7
 platform: ruby
 authors:
 - Segment.io
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-03 00:00:00.000000000 Z
+date: 2019-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -136,6 +136,7 @@ files:
 - lib/segment/analytics/backoff_policy.rb
 - lib/segment/analytics/client.rb
 - lib/segment/analytics/defaults.rb
+- lib/segment/analytics/field_parser.rb
 - lib/segment/analytics/logging.rb
 - lib/segment/analytics/message_batch.rb
 - lib/segment/analytics/request.rb