analytics-ruby 2.2.3.pre → 2.2.4.pre

data/spec/segment/analytics/backoff_policy_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe BackoffPolicy do
+      describe '#initialize' do
+        context 'no options are given' do
+          it 'sets default min_timeout_ms' do
+            actual = subject.instance_variable_get(:@min_timeout_ms)
+            expect(actual).to eq(described_class::MIN_TIMEOUT_MS)
+          end
+
+          it 'sets default max_timeout_ms' do
+            actual = subject.instance_variable_get(:@max_timeout_ms)
+            expect(actual).to eq(described_class::MAX_TIMEOUT_MS)
+          end
+
+          it 'sets default multiplier' do
+            actual = subject.instance_variable_get(:@multiplier)
+            expect(actual).to eq(described_class::MULTIPLIER)
+          end
+
+          it 'sets default randomization factor' do
+            actual = subject.instance_variable_get(:@randomization_factor)
+            expect(actual).to eq(described_class::RANDOMIZATION_FACTOR)
+          end
+        end
+
+        context 'options are given' do
+          let(:min_timeout_ms) { 1234 }
+          let(:max_timeout_ms) { 5678 }
+          let(:multiplier) { 24 }
+          let(:randomization_factor) { 0.4 }
+
+          let(:options) do
+            {
+              min_timeout_ms: min_timeout_ms,
+              max_timeout_ms: max_timeout_ms,
+              multiplier: multiplier,
+              randomization_factor: randomization_factor
+            }
+          end
+
+          subject { described_class.new(options) }
+
+          it 'sets passed in min_timeout_ms' do
+            actual = subject.instance_variable_get(:@min_timeout_ms)
+            expect(actual).to eq(min_timeout_ms)
+          end
+
+          it 'sets passed in max_timeout_ms' do
+            actual = subject.instance_variable_get(:@max_timeout_ms)
+            expect(actual).to eq(max_timeout_ms)
+          end
+
+          it 'sets passed in multiplier' do
+            actual = subject.instance_variable_get(:@multiplier)
+            expect(actual).to eq(multiplier)
+          end
+
+          it 'sets passed in randomization_factor' do
+            actual = subject.instance_variable_get(:@randomization_factor)
+            expect(actual).to eq(randomization_factor)
+          end
+        end
+      end
+
+      describe '#next_interval' do
+        subject {
+          described_class.new(
+            min_timeout_ms: 1000,
+            max_timeout_ms: 10000,
+            multiplier: 2,
+            randomization_factor: 0.5
+          )
+        }
+
+        it 'returns exponentially increasing durations' do
+          expect(subject.next_interval).to be_within(500).of(1000)
+          expect(subject.next_interval).to be_within(1000).of(2000)
+          expect(subject.next_interval).to be_within(2000).of(4000)
+          expect(subject.next_interval).to be_within(4000).of(8000)
+        end
+
+        it 'caps maximum duration at max_timeout_secs' do
+          10.times { subject.next_interval }
+          expect(subject.next_interval).to eq(10000)
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics/client_spec.rb

@@ -3,7 +3,12 @@ require 'spec_helper'
 module Segment
   class Analytics
     describe Client do
-      let(:client) { Client.new :write_key => WRITE_KEY }
+      let(:client) do
+        Client.new(:write_key => WRITE_KEY).tap { |client|
+          # Ensure that worker doesn't consume items from the queue
+          client.instance_variable_set(:@worker, NoopWorker.new)
+        }
+      end
       let(:queue) { client.instance_variable_get :@queue }
 
       describe '#initialize' do
@@ -38,13 +43,13 @@ module Segment
             client.track({
               :user_id => 'user',
               :event => 'Event',
-              :properties => [1,2,3]
+              :properties => [1, 2, 3]
             })
           }.to raise_error(ArgumentError)
         end
 
         it 'uses the timestamp given' do
-          time = Time.parse("1990-07-16 13:30:00.123 UTC")
+          time = Time.parse('1990-07-16 13:30:00.123 UTC')
 
           client.track({
             :event => 'testing the timestamp',
@@ -78,22 +83,22 @@ module Segment
             :properties => {
               :time => Time.utc(2013),
               :time_with_zone =>  Time.zone.parse('2013-01-01'),
-              :date_time => DateTime.new(2013,1,1),
-              :date => Date.new(2013,1,1),
+              :date_time => DateTime.new(2013, 1, 1),
+              :date => Date.new(2013, 1, 1),
               :nottime => 'x'
             }
           })
           message = queue.pop
 
-          expect(message[:properties][:time]).to eq('2013-01-01T00:00:00.000Z')
-          expect(message[:properties][:time_with_zone]).to eq('2013-01-01T00:00:00.000Z')
-          expect(message[:properties][:date_time]).to eq('2013-01-01T00:00:00.000Z')
-          expect(message[:properties][:date]).to eq('2013-01-01')
-          expect(message[:properties][:nottime]).to eq('x')
+          properties = message[:properties]
+          expect(properties[:time]).to eq('2013-01-01T00:00:00.000Z')
+          expect(properties[:time_with_zone]).to eq('2013-01-01T00:00:00.000Z')
+          expect(properties[:date_time]).to eq('2013-01-01T00:00:00.000+00:00')
+          expect(properties[:date]).to eq('2013-01-01')
+          expect(properties[:nottime]).to eq('x')
         end
       end
 
-
       describe '#identify' do
         it 'errors without any user id' do
           expect { client.identify({}) }.to raise_error(ArgumentError)
@@ -119,19 +124,20 @@ module Segment
             :traits => {
               :time => Time.utc(2013),
               :time_with_zone =>  Time.zone.parse('2013-01-01'),
-              :date_time => DateTime.new(2013,1,1),
-              :date => Date.new(2013,1,1),
+              :date_time => DateTime.new(2013, 1, 1),
+              :date => Date.new(2013, 1, 1),
               :nottime => 'x'
             }
           })
 
           message = queue.pop
 
-          expect(message[:traits][:time]).to eq('2013-01-01T00:00:00.000Z')
-          expect(message[:traits][:time_with_zone]).to eq('2013-01-01T00:00:00.000Z')
-          expect(message[:traits][:date_time]).to eq('2013-01-01T00:00:00.000Z')
-          expect(message[:traits][:date]).to eq('2013-01-01')
-          expect(message[:traits][:nottime]).to eq('x')
+          traits = message[:traits]
+          expect(traits[:time]).to eq('2013-01-01T00:00:00.000Z')
+          expect(traits[:time_with_zone]).to eq('2013-01-01T00:00:00.000Z')
+          expect(traits[:date_time]).to eq('2013-01-01T00:00:00.000+00:00')
+          expect(traits[:date]).to eq('2013-01-01')
+          expect(traits[:nottime]).to eq('x')
         end
       end
 
@@ -156,10 +162,6 @@ module Segment
       end
 
       describe '#group' do
-        after do
-          client.flush
-        end
-
         it 'errors without group_id' do
           expect { client.group :user_id => 'foo' }.to raise_error(ArgumentError)
         end
@@ -183,19 +185,20 @@ module Segment
             :traits => {
               :time => Time.utc(2013),
               :time_with_zone =>  Time.zone.parse('2013-01-01'),
-              :date_time => DateTime.new(2013,1,1),
-              :date => Date.new(2013,1,1),
+              :date_time => DateTime.new(2013, 1, 1),
+              :date => Date.new(2013, 1, 1),
               :nottime => 'x'
             }
           })
 
           message = queue.pop
 
-          expect(message[:traits][:time]).to eq('2013-01-01T00:00:00.000Z')
-          expect(message[:traits][:time_with_zone]).to eq('2013-01-01T00:00:00.000Z')
-          expect(message[:traits][:date_time]).to eq('2013-01-01T00:00:00.000Z')
-          expect(message[:traits][:date]).to eq('2013-01-01')
-          expect(message[:traits][:nottime]).to eq('x')
+          traits = message[:traits]
+          expect(traits[:time]).to eq('2013-01-01T00:00:00.000Z')
+          expect(traits[:time_with_zone]).to eq('2013-01-01T00:00:00.000Z')
+          expect(traits[:date_time]).to eq('2013-01-01T00:00:00.000+00:00')
+          expect(traits[:date]).to eq('2013-01-01')
+          expect(traits[:nottime]).to eq('x')
         end
       end
 
@@ -232,31 +235,35 @@ module Segment
       end
 
       describe '#flush' do
+        let(:client_with_worker) { Client.new(:write_key => WRITE_KEY) }
+
         it 'waits for the queue to finish on a flush' do
-          client.identify Queued::IDENTIFY
-          client.track Queued::TRACK
-          client.flush
+          client_with_worker.identify Queued::IDENTIFY
+          client_with_worker.track Queued::TRACK
+          client_with_worker.flush
 
-          expect(client.queued_messages).to eq(0)
+          expect(client_with_worker.queued_messages).to eq(0)
         end
 
-        it 'completes when the process forks' do
-          client.identify Queued::IDENTIFY
+        unless defined? JRUBY_VERSION
+          it 'completes when the process forks' do
+            client_with_worker.identify Queued::IDENTIFY
 
-          Process.fork do
-            client.track Queued::TRACK
-            client.flush
-            expect(client.queued_messages).to eq(0)
-          end
+            Process.fork do
+              client_with_worker.track Queued::TRACK
+              client_with_worker.flush
+              expect(client_with_worker.queued_messages).to eq(0)
+            end
 
-          Process.wait
-        end unless defined? JRUBY_VERSION
+            Process.wait
+          end
+        end
       end
 
       context 'common' do
         check_property = proc { |msg, k, v| msg[k] && msg[k] == v }
 
-        let(:data) { { :user_id => 1, :group_id => 2, :previous_id => 3, :anonymous_id => 4, :message_id => 5, :event => "coco barked", :name => "coco" } }
+        let(:data) { { :user_id => 1, :group_id => 2, :previous_id => 3, :anonymous_id => 4, :message_id => 5, :event => 'coco barked', :name => 'coco' } }
 
         it 'does not convert ids given as fixnums to strings' do
           [:track, :screen, :page, :identify].each do |s|
@@ -268,6 +275,16 @@ module Segment
           end
         end
 
+        it 'returns false if queue is full' do
+          client.instance_variable_set(:@max_queue_size, 1)
+
+          [:track, :screen, :page, :group, :identify, :alias].each do |s|
+            expect(client.send(s, data)).to eq(true)
+            expect(client.send(s, data)).to eq(false) # Queue is full
+            queue.pop(true)
+          end
+        end
+
         it 'converts message id to string' do
           [:track, :screen, :page, :group, :identify, :alias].each do |s|
             client.send(s, data)
@@ -299,7 +316,7 @@ module Segment
 
         it 'sends integrations' do
           [:track, :screen, :page, :group, :identify, :alias].each do |s|
-            client.send s, :integrations => { :All => true, :Salesforce => false }, :user_id => 1, :group_id => 2, :previous_id => 3, :anonymous_id => 4, :event => "coco barked", :name => "coco"
+            client.send s, :integrations => { :All => true, :Salesforce => false }, :user_id => 1, :group_id => 2, :previous_id => 3, :anonymous_id => 4, :event => 'coco barked', :name => 'coco'
             message = queue.pop(true)
             expect(message[:integrations][:All]).to eq(true)
             expect(message[:integrations][:Salesforce]).to eq(false)

data/spec/segment/analytics/e2e_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module Segment
+  # End-to-end tests that send events to a segment source and verifies that a
+  # webhook connected to the source (configured manually via the app) is able
+  # to receive the data sent by this library.
+  describe 'End-to-end tests', e2e: true do
+    # Segment write key for
+    # https://app.segment.com/segment-libraries/sources/analytics_ruby_e2e_test/overview.
+    #
+    # This source is configured to send events to the Runscope bucket used by
+    # this test.
+    WRITE_KEY = 'qhdMksLsQTi9MES3CHyzsWRRt4ub5VM6'
+
+    # Runscope bucket key for https://www.runscope.com/stream/umkvkgv7ndby
+    RUNSCOPE_BUCKET_KEY = 'umkvkgv7ndby'
+
+    let(:client) { Segment::Analytics.new(write_key: WRITE_KEY) }
+    let(:runscope_client) { RunscopeClient.new(ENV.fetch('RUNSCOPE_TOKEN')) }
+
+    it 'tracks events' do
+      id = SecureRandom.uuid
+      client.track(
+        user_id: 'dummy_user_id',
+        event: 'E2E Test',
+        properties: { id: id }
+      )
+      client.flush
+
+      # Allow events to propagate to runscope
+      eventually(timeout: 30) {
+        expect(has_matching_request?(id)).to eq(true)
+      }
+    end
+
+    def has_matching_request?(id)
+      captured_requests = runscope_client.requests(RUNSCOPE_BUCKET_KEY)
+      captured_requests.any? do |request|
+        begin
+          body = JSON.parse(request['body'])
+          body['properties'] && body['properties']['id'] == id
+        rescue JSON::ParserError
+          false
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics/message_batch_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe MessageBatch do
+      subject { described_class.new(100) }
+
+      describe '#<<' do
+        it 'appends messages' do
+          subject << Message.new('a' => 'b')
+          expect(subject.length).to eq(1)
+        end
+
+        it 'rejects messages that exceed the maximum allowed size' do
+          max_bytes = Defaults::Message::MAX_BYTES
+          hash = { 'a' => 'b' * max_bytes }
+          message = Message.new(hash)
+
+          subject << message
+          expect(subject.length).to eq(0)
+        end
+      end
+
+      describe '#full?' do
+        it 'returns true once item count is exceeded' do
+          99.times { subject << Message.new(a: 'b') }
+          expect(subject.full?).to be(false)
+
+          subject << Message.new(a: 'b')
+          expect(subject.full?).to be(true)
+        end
+
+        it 'returns true once max size is almost exceeded' do
+          message = Message.new(a: 'b' * (Defaults::Message::MAX_BYTES - 10))
+
+          # Each message is under the individual limit
+          expect(message.json_size).to be < Defaults::Message::MAX_BYTES
+
+          # Size of the batch is over the limit
+          expect(50 * message.json_size).to be > Defaults::MessageBatch::MAX_BYTES
+
+          expect(subject.full?).to be(false)
+          50.times { subject << message }
+          expect(subject.full?).to be(true)
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics/message_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe Message do
+      describe '#to_json' do
+        it 'caches JSON conversions' do
+          # Keeps track of the number of times to_json was called
+          nested_obj = Class.new do
+            attr_reader :to_json_call_count
+
+            def initialize
+              @to_json_call_count = 0
+            end
+
+            def to_json(*_)
+              @to_json_call_count += 1
+              '{}'
+            end
+          end.new
+
+          message = Message.new('some_key' => nested_obj)
+          expect(nested_obj.to_json_call_count).to eq(0)
+
+          message.to_json
+          expect(nested_obj.to_json_call_count).to eq(1)
+
+          # When called a second time, the call count shouldn't increase
+          message.to_json
+          expect(nested_obj.to_json_call_count).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/segment/analytics/request_spec.rb

@@ -37,19 +37,25 @@ module Segment
 
         context 'no options are set' do
           it 'sets a default path' do
-            expect(subject.instance_variable_get(:@path)).to eq(described_class::PATH)
+            path = subject.instance_variable_get(:@path)
+            expect(path).to eq(described_class::PATH)
           end
 
           it 'sets a default retries' do
-            expect(subject.instance_variable_get(:@retries)).to eq(described_class::RETRIES)
+            retries = subject.instance_variable_get(:@retries)
+            expect(retries).to eq(described_class::RETRIES)
           end
 
-          it 'sets a default backoff' do
-            expect(subject.instance_variable_get(:@backoff)).to eq(described_class::BACKOFF)
+          it 'sets a default backoff policy' do
+            backoff_policy = subject.instance_variable_get(:@backoff_policy)
+            expect(backoff_policy).to be_a(Segment::Analytics::BackoffPolicy)
           end
 
           it 'initializes a new Net::HTTP with default host and port' do
-            expect(Net::HTTP).to receive(:new).with(described_class::HOST, described_class::PORT)
+            expect(Net::HTTP).to receive(:new).with(
+              described_class::HOST,
+              described_class::PORT
+            )
             described_class.new
           end
         end
@@ -57,14 +63,14 @@ module Segment
         context 'options are given' do
           let(:path) { 'my/cool/path' }
           let(:retries) { 1234 }
-          let(:backoff) { 10 }
+          let(:backoff_policy) { FakeBackoffPolicy.new([1, 2, 3]) }
           let(:host) { 'http://www.example.com' }
           let(:port) { 8080 }
           let(:options) do
             {
               path: path,
               retries: retries,
-              backoff: backoff,
+              backoff_policy: backoff_policy,
               host: host,
               port: port
             }
@@ -80,8 +86,9 @@ module Segment
             expect(subject.instance_variable_get(:@retries)).to eq(retries)
           end
 
-          it 'sets passed in backoff' do
-            expect(subject.instance_variable_get(:@backoff)).to eq(backoff)
+          it 'sets passed in backoff backoff policy' do
+            expect(subject.instance_variable_get(:@backoff_policy))
+              .to eq(backoff_policy)
           end
 
           it 'initializes a new Net::HTTP with passed in host and port' do
@@ -92,7 +99,9 @@ module Segment
       end
 
       describe '#post' do
-        let(:response) { Net::HTTPResponse.new(http_version, status_code, response_body) }
+        let(:response) {
+          Net::HTTPResponse.new(http_version, status_code, response_body)
+        }
         let(:http_version) { 1.1 }
         let(:status_code) { 200 }
         let(:response_body) { {}.to_json }
@@ -100,19 +109,29 @@ module Segment
         let(:batch) { [] }
 
         before do
-          allow(subject.instance_variable_get(:@http)).to receive(:request) { response }
+          http = subject.instance_variable_get(:@http)
+          allow(http).to receive(:request) { response }
           allow(response).to receive(:body) { response_body }
         end
 
         it 'initalizes a new Net::HTTP::Post with path and default headers' do
           path = subject.instance_variable_get(:@path)
-          default_headers = { 'Content-Type' => 'application/json', 'accept' => 'application/json' }
-          expect(Net::HTTP::Post).to receive(:new).with(path, default_headers).and_call_original
+          default_headers = {
+            'Content-Type' => 'application/json',
+            'Accept' => 'application/json',
+            'User-Agent' => "analytics-ruby/#{Analytics::VERSION}"
+          }
+          expect(Net::HTTP::Post).to receive(:new).with(
+            path, default_headers
+          ).and_call_original
+
           subject.post(write_key, batch)
         end
 
         it 'adds basic auth to the Net::HTTP::Post' do
-          expect_any_instance_of(Net::HTTP::Post).to receive(:basic_auth).with(write_key, nil)
+          expect_any_instance_of(Net::HTTP::Post).to receive(:basic_auth)
+            .with(write_key, nil)
+
           subject.post(write_key, batch)
         end
 
@@ -136,6 +155,41 @@ module Segment
         end
 
         context 'a real request' do
+          RSpec.shared_examples('retried request') do |status_code, body|
+            let(:status_code) { status_code }
+            let(:body) { body }
+            let(:retries) { 4 }
+            let(:backoff_policy) { FakeBackoffPolicy.new([1000, 1000, 1000]) }
+            subject {
+              described_class.new(retries: retries,
+                                  backoff_policy: backoff_policy)
+            }
+
+            it 'retries the request' do
+              expect(subject)
+                .to receive(:sleep)
+                .exactly(retries - 1).times
+                .with(1)
+                .and_return(nil)
+              subject.post(write_key, batch)
+            end
+          end
+
+          RSpec.shared_examples('non-retried request') do |status_code, body|
+            let(:status_code) { status_code }
+            let(:body) { body }
+            let(:retries) { 4 }
+            let(:backoff) { 1 }
+            subject { described_class.new(retries: retries, backoff: backoff) }
+
+            it 'does not retry the request' do
+              expect(subject)
+                .to receive(:sleep)
+                .never
+              subject.post(write_key, batch)
+            end
+          end
+
           context 'request is successful' do
             let(:status_code) { 201 }
             it 'returns a response code' do
@@ -156,33 +210,32 @@ module Segment
             end
           end
 
-          context 'request or parsing of response results in an exception' do
-            let(:response_body) { 'Malformed JSON ---' }
+          context 'a request returns a failure status code' do
+            # Server errors must be retried
+            it_behaves_like('retried request', 500, '{}')
+            it_behaves_like('retried request', 503, '{}')
 
-            let(:backoff) { 0 }
+            # All 4xx errors other than 429 (rate limited) must be retried
+            it_behaves_like('retried request', 429, '{}')
+            it_behaves_like('non-retried request', 404, '{}')
+            it_behaves_like('non-retried request', 400, '{}')
+          end
 
-            subject { described_class.new(retries: retries, backoff: backoff) }
+          context 'request or parsing of response results in an exception' do
+            let(:response_body) { 'Malformed JSON ---' }
 
-            context 'remaining retries is > 1' do
-              let(:retries) { 2 }
+            subject { described_class.new(retries: 0) }
 
-              it 'sleeps' do
-                expect(subject).to receive(:sleep).exactly(retries - 1).times
-                subject.post(write_key, batch)
-              end
+            it 'returns a -1 for status' do
+              expect(subject.post(write_key, batch).status).to eq(-1)
             end
 
-            context 'remaining retries is 1' do
-              let(:retries) { 1 }
-
-              it 'returns a -1 for status' do
-                expect(subject.post(write_key, batch).status).to eq(-1)
-              end
-
-              it 'has a connection error' do
-                expect(subject.post(write_key, batch).error).to match(/Connection error/)
-              end
+            it 'has a connection error' do
+              error = subject.post(write_key, batch).error
+              expect(error).to match(/Connection error/)
             end
+
+            it_behaves_like('retried request', 200, 'Malformed JSON ---')
           end
         end
       end