analytics-ruby 2.2.6 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 472dcf42eeb6b9d83166a526ebeb81bfbbdc74a429511776fedac53ae585da27
-  data.tar.gz: 70d5bfbf53332c3899cb4cc0071a068c25da7fabee8e934ced0d335bbb08c45f
+  metadata.gz: cdf8f490d498d4be6df74dc0e07337670f201aecf2197df18a0cd6bad097f0ec
+  data.tar.gz: 5f578db1517f5d9d376c0dfc3b19cdfb68afcc84b80d23cc929c8bf4038bfa3c
 SHA512:
-  metadata.gz: 112f00cdfb0e27ab41ae0c74ebe76d8fba6777acd71ec0a46fc6576948f65a096668c59354393ef600f961631f6cf1938bde3bcbb4ff09aafd4fcf1ed73a2aa9
-  data.tar.gz: 4af5e31b75e80dd20dacf7d3e5aeb58ce2e1280337dbe82b69b63c1588ba650d774a9625f00f930b0a25df612f8d7654ae16947cd5b3369ce6e6e3b4880e6483
+  metadata.gz: 6d05d3ba281a5af2d16e883afb17b285c5e5c2ee6500041646c136a412a16fd8f659f848e8f72d1bf86eeaddd9ae61a0565b49d051834d57ca0e9446ef6c8396
+  data.tar.gz: b1fb05a4a057fe04dc39ed7234bc07cf2d401e9c5e2ca42eea64e9ff8c58bab879e9f4d42efad31128dcc4d8621e7c534f1f3b6c8f262049b78e4299fc16afe5

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.rb

@@ -1,11 +1,13 @@
 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'
+require 'segment/analytics/transport'
 require 'segment/analytics/response'
 require 'segment/analytics/logging'
+require 'segment/analytics/test_queue'
 
 module Segment
   class Analytics
@@ -17,7 +19,7 @@ module Segment
     # @option options [Boolean] :stub (false) If true, requests don't hit the
     #   server and are stubbed to be successful.
     def initialize(options = {})
-      Request.stub = options[:stub] if options.has_key?(:stub)
+      Transport.stub = options[:stub] if options.has_key?(:stub)
       @client = Segment::Analytics::Client.new options
     end
 

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

data/lib/segment/analytics/message_batch.rb

@@ -5,6 +5,8 @@ module Segment
   class Analytics
     # A batch of `Message`s to be sent to the API
     class MessageBatch
+      class JSONGenerationError < StandardError; end
+
       extend Forwardable
       include Segment::Analytics::Logging
       include Segment::Analytics::Defaults::MessageBatch
@@ -16,8 +18,13 @@ module Segment
       end
 
       def <<(message)
-        message_json_size = message.to_json.bytesize
+        begin
+          message_json = message.to_json
+        rescue StandardError => e
+          raise JSONGenerationError, "Serialization error: #{e}"
+        end
 
+        message_json_size = message_json.bytesize
         if message_too_big?(message_json_size)
           logger.error('a message exceeded the maximum allowed size')
         else

data/lib/segment/analytics/test_queue.rb

@@ -0,0 +1,56 @@
+module Segment
+  class Analytics
+    class TestQueue
+      attr_reader :messages
+
+      def initialize
+        reset!
+      end
+
+      def [](key)
+        all[key]
+      end
+
+      def count
+        all.count
+      end
+
+      def <<(message)
+        all << message
+        send(message[:type]) << message
+      end
+
+      def alias
+        messages[:alias] ||= []
+      end
+
+      def all
+        messages[:all] ||= []
+      end
+
+      def group
+        messages[:group] ||= []
+      end
+
+      def identify
+        messages[:identify] ||= []
+      end
+
+      def page
+        messages[:page] ||= []
+      end
+
+      def screen
+        messages[:screen] ||= []
+      end
+
+      def track
+        messages[:track] ||= []
+      end
+
+      def reset!
+        @messages = {}
+      end
+    end
+  end
+end

data/lib/segment/analytics/{request.rb → transport.rb}

@@ -9,13 +9,11 @@ require 'json'
 
 module Segment
   class Analytics
-    class Request
+    class Transport
       include Segment::Analytics::Defaults::Request
       include Segment::Analytics::Utils
       include Segment::Analytics::Logging
 
-      # public: Creates a new request object to send analytics batch
-      #
       def initialize(options = {})
         options[:host] ||= HOST
         options[:port] ||= PORT
@@ -34,10 +32,10 @@ module Segment
         @http = http
       end
 
-      # public: Posts the write key and batch of messages to the API.
+      # Sends a batch of messages to the API
       #
-      # returns - Response of the status and error if it exists
-      def post(write_key, batch)
+      # @return [Response] API response
+      def send(write_key, batch)
         logger.debug("Sending request for #{batch.length} items")
 
         last_response, exception = retry_with_backoff(@retries) do
@@ -59,6 +57,11 @@ module Segment
         end
       end
 
+      # Closes a persistent connection if it exists
+      def shutdown
+        @http.finish if @http.started?
+      end
+
       private
 
       def should_retry_request?(status_code, body)
@@ -113,10 +116,11 @@ module Segment
 
         if self.class.stub
           logger.debug "stubbed request to #{@path}: " \
-            "write key = #{write_key}, batch = JSON.generate(#{batch})"
+            "write key = #{write_key}, batch = #{JSON.generate(batch)}"
 
           [200, '{}']
         else
+          @http.start unless @http.started? # Maintain a persistent connection
           response = @http.request(request, payload)
           [response.code.to_i, response.body]
         end

data/lib/segment/analytics/utils.rb

@@ -64,12 +64,8 @@ module Segment
         end
       end
 
-      def time_in_iso8601(time, fraction_digits = 3)
-        fraction = if fraction_digits > 0
-                     ('.%06i' % time.usec)[0, fraction_digits + 1]
-                   end
-
-        "#{time.strftime('%Y-%m-%dT%H:%M:%S')}#{fraction}#{formatted_offset(time, true, 'Z')}"
+      def time_in_iso8601(time)
+        "#{time.strftime('%Y-%m-%dT%H:%M:%S.%6N')}#{formatted_offset(time, true, 'Z')}"
       end
 
       def date_in_iso8601(date)

data/lib/segment/analytics/version.rb

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

data/lib/segment/analytics/worker.rb

@@ -1,6 +1,6 @@
 require 'segment/analytics/defaults'
 require 'segment/analytics/message_batch'
-require 'segment/analytics/request'
+require 'segment/analytics/transport'
 require 'segment/analytics/utils'
 
 module Segment
@@ -29,6 +29,7 @@ module Segment
         batch_size = options[:batch_size] || Defaults::MessageBatch::MAX_SIZE
         @batch = MessageBatch.new(batch_size)
         @lock = Mutex.new
+        @transport = Transport.new
       end
 
       # public: Continuously runs the loop to check for new events
@@ -38,15 +39,16 @@ module Segment
           return if @queue.empty?
 
           @lock.synchronize do
-            @batch << @queue.pop until @batch.full? || @queue.empty?
+            consume_message_from_queue! until @batch.full? || @queue.empty?
           end
 
-          res = Request.new.post @write_key, @batch
-
+          res = @transport.send @write_key, @batch
           @on_error.call(res.status, res.error) unless res.status == 200
 
           @lock.synchronize { @batch.clear }
         end
+      ensure
+        @transport.shutdown
       end
 
       # public: Check whether we have outstanding requests.
@@ -54,6 +56,14 @@ module Segment
       def is_requesting?
         @lock.synchronize { !@batch.empty? }
       end
+
+      private
+
+      def consume_message_from_queue!
+        @batch << @queue.pop
+      rescue MessageBatch::JSONGenerationError => e
+        @on_error.call(-1, e.to_s)
+      end
     end
   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.3.1
 platform: ruby
 authors:
 - Segment.io
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-03 00:00:00.000000000 Z
+date: 2021-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -136,10 +136,12 @@ 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
 - lib/segment/analytics/response.rb
+- lib/segment/analytics/test_queue.rb
+- lib/segment/analytics/transport.rb
 - lib/segment/analytics/utils.rb
 - lib/segment/analytics/version.rb
 - lib/segment/analytics/worker.rb
@@ -155,14 +157,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Segment.io analytics library