analytics-ruby 2.2.6.pre → 2.2.6

data/RELEASING.md

@@ -1,9 +0,0 @@
-Releasing
-=========
-
- 1. Verify everything works with `make check build`.
- 2. Bump version in [`version.rb`](https://github.com/segmentio/analytics-ruby/blob/master/lib/segment/analytics/version.rb).
- 3. Update [`History.md`](https://github.com/segmentio/analytics-ruby/blob/master/History.md).
- 4. Commit and tag `git commit -am "Release {version}" && git tag -a {version} -m "Version {version}"`.
- 5. Upload to Github with `git push -u origin master && git push --tags`.
-The tagged commit will be pushed to RubyGems via Travis.

data/Rakefile

@@ -1,33 +0,0 @@
-require 'rspec/core/rake_task'
-
-default_tasks = []
-
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = 'spec/segment/**/*_spec.rb'
-  spec.rspec_opts = "--tag ~e2e" if ENV["RUN_E2E_TESTS"] != "true"
-end
-
-default_tasks << :spec
-
-# Isolated tests are run as separate rake tasks so that gem conflicts can be
-# tests in different processes
-Dir.glob('spec/isolated/**/*.rb').each do |isolated_test_path|
-  RSpec::Core::RakeTask.new(isolated_test_path) do |spec|
-    spec.pattern = isolated_test_path
-  end
-
-  default_tasks << isolated_test_path
-end
-
-# Rubocop doesn't support < 2.1
-if RUBY_VERSION >= "2.1"
-  require 'rubocop/rake_task'
-
-  RuboCop::RakeTask.new(:rubocop) do |task|
-    task.patterns = ['lib/**/*.rb','spec/**/*.rb',]
-  end
-
-  default_tasks << :rubocop
-end
-
-task :default => default_tasks

data/analytics-ruby.gemspec

@@ -1,37 +0,0 @@
-require File.expand_path('../lib/segment/analytics/version', __FILE__)
-
-Gem::Specification.new do |spec|
-  spec.name = 'analytics-ruby'
-  spec.version = Segment::Analytics::VERSION
-  spec.files = Dir.glob('**/*')
-  spec.require_paths = ['lib']
-  spec.bindir = 'bin'
-  spec.executables = ['analytics']
-  spec.summary = 'Segment.io analytics library'
-  spec.description = 'The Segment.io ruby analytics library'
-  spec.authors = ['Segment.io']
-  spec.email = 'friends@segment.io'
-  spec.homepage = 'https://github.com/segmentio/analytics-ruby'
-  spec.license = 'MIT'
-
-  # Ruby 1.8 requires json
-  spec.add_dependency 'json', ['~> 1.7'] if RUBY_VERSION < "1.9"
-  spec.add_dependency 'commander', '~> 4.4'
-
-  spec.add_development_dependency 'rake', '~> 10.3'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'tzinfo', '1.2.1'
-  spec.add_development_dependency 'activesupport', '~> 4.1.11'
-  spec.add_development_dependency 'faraday', '~> 0.13'
-  spec.add_development_dependency 'pmap', '~> 1.1'
-
-  if RUBY_VERSION >= '2.0' && RUBY_PLATFORM != 'java'
-    spec.add_development_dependency 'oj', '~> 3.6.2'
-  end
-
-  if RUBY_VERSION >= "2.1"
-    spec.add_development_dependency 'rubocop', '~> 0.51.0'
-  end
-
-  spec.add_development_dependency 'codecov', '~> 0.1.4'
-end

data/codecov.yml

@@ -1,2 +0,0 @@
-ignore:
-  - "spec/**/*"

data/spec/helpers/runscope_client.rb

@@ -1,38 +0,0 @@
-require 'faraday'
-require 'pmap'
-
-class RunscopeClient
-  def initialize(api_token)
-    headers = { 'Authorization' => "Bearer #{api_token}" }
-    @conn = Faraday.new('https://api.runscope.com', headers: headers)
-  end
-
-  def requests(bucket_key)
-    with_retries(3) do
-      response = @conn.get("/buckets/#{bucket_key}/messages", count: 20)
-
-      raise "Runscope error. #{response.body}" unless response.status == 200
-
-      message_uuids = JSON.parse(response.body)['data'].map { |message|
-        message.fetch('uuid')
-      }
-
-      message_uuids.pmap { |uuid|
-        response = @conn.get("/buckets/#{bucket_key}/messages/#{uuid}")
-        raise "Runscope error. #{response.body}" unless response.status == 200
-        JSON.parse(response.body).fetch('data').fetch('request')
-      }
-    end
-  end
-
-  private
-
-  def with_retries(max_retries)
-    retries ||= 0
-    yield
-  rescue StandardError => e
-    retries += 1
-    retry if retries < max_retries
-    raise e
-  end
-end

data/spec/isolated/json_example.rb

@@ -1,9 +0,0 @@
-RSpec.shared_examples 'message_batch_json' do
-  it 'MessageBatch generates proper JSON' do
-    batch = Segment::Analytics::MessageBatch.new(100)
-    batch << { 'a' => 'b' }
-    batch << { 'c' => 'd' }
-
-    expect(JSON.generate(batch)).to eq('[{"a":"b"},{"c":"d"}]')
-  end
-end

data/spec/isolated/with_active_support.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-require 'isolated/json_example'
-
-describe 'with active_support' do
-  before do
-    require 'active_support'
-    require 'active_support/json'
-  end
-
-  include_examples 'message_batch_json'
-end

data/spec/isolated/with_active_support_and_oj.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'isolated/json_example'
-
-if RUBY_VERSION >= '2.0' && RUBY_PLATFORM != 'java'
-  describe 'with active_support and oj' do
-    before do
-      require 'active_support'
-      require 'active_support/json'
-
-      require 'oj'
-      Oj.mimic_JSON
-    end
-
-    include_examples 'message_batch_json'
-  end
-end

data/spec/isolated/with_oj.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-require 'isolated/json_example'
-
-if RUBY_VERSION >= '2.0' && RUBY_PLATFORM != 'java'
-  describe 'with oj' do
-    before do
-      require 'oj'
-      Oj.mimic_JSON
-    end
-
-    include_examples 'message_batch_json'
-  end
-end

data/spec/segment/analytics/backoff_policy_spec.rb

@@ -1,92 +0,0 @@
-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

@@ -1,328 +0,0 @@
-require 'spec_helper'
-
-module Segment
-  class Analytics
-    describe Client do
-      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
-        it 'errors if no write_key is supplied' do
-          expect { Client.new }.to raise_error(ArgumentError)
-        end
-
-        it 'does not error if a write_key is supplied' do
-          expect do
-            Client.new :write_key => WRITE_KEY
-          end.to_not raise_error
-        end
-
-        it 'does not error if a write_key is supplied as a string' do
-          expect do
-            Client.new 'write_key' => WRITE_KEY
-          end.to_not raise_error
-        end
-      end
-
-      describe '#track' do
-        it 'errors without an event' do
-          expect { client.track(:user_id => 'user') }.to raise_error(ArgumentError)
-        end
-
-        it 'errors without a user_id' do
-          expect { client.track(:event => 'Event') }.to raise_error(ArgumentError)
-        end
-
-        it 'errors if properties is not a hash' do
-          expect {
-            client.track({
-              :user_id => 'user',
-              :event => 'Event',
-              :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')
-
-          client.track({
-            :event => 'testing the timestamp',
-            :user_id => 'joe',
-            :timestamp => time
-          })
-
-          msg = queue.pop
-
-          expect(Time.parse(msg[:timestamp])).to eq(time)
-        end
-
-        it 'does not error with the required options' do
-          expect do
-            client.track Queued::TRACK
-            queue.pop
-          end.to_not raise_error
-        end
-
-        it 'does not error when given string keys' do
-          expect do
-            client.track Utils.stringify_keys(Queued::TRACK)
-            queue.pop
-          end.to_not raise_error
-        end
-
-        it 'converts time and date traits into iso8601 format' do
-          client.track({
-            :user_id => 'user',
-            :event => 'Event',
-            :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),
-              :nottime => 'x'
-            }
-          })
-          message = queue.pop
-
-          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)
-        end
-
-        it 'does not error with the required options' do
-          expect do
-            client.identify Queued::IDENTIFY
-            queue.pop
-          end.to_not raise_error
-        end
-
-        it 'does not error with the required options as strings' do
-          expect do
-            client.identify Utils.stringify_keys(Queued::IDENTIFY)
-            queue.pop
-          end.to_not raise_error
-        end
-
-        it 'converts time and date traits into iso8601 format' do
-          client.identify({
-            :user_id => 'user',
-            :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),
-              :nottime => 'x'
-            }
-          })
-
-          message = queue.pop
-
-          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
-
-      describe '#alias' do
-        it 'errors without from' do
-          expect { client.alias :user_id => 1234 }.to raise_error(ArgumentError)
-        end
-
-        it 'errors without to' do
-          expect { client.alias :previous_id => 1234 }.to raise_error(ArgumentError)
-        end
-
-        it 'does not error with the required options' do
-          expect { client.alias ALIAS }.to_not raise_error
-        end
-
-        it 'does not error with the required options as strings' do
-          expect do
-            client.alias Utils.stringify_keys(ALIAS)
-          end.to_not raise_error
-        end
-      end
-
-      describe '#group' do
-        it 'errors without group_id' do
-          expect { client.group :user_id => 'foo' }.to raise_error(ArgumentError)
-        end
-
-        it 'errors without user_id' do
-          expect { client.group :group_id => 'foo' }.to raise_error(ArgumentError)
-        end
-
-        it 'does not error with the required options' do
-          client.group Queued::GROUP
-        end
-
-        it 'does not error with the required options as strings' do
-          client.group Utils.stringify_keys(Queued::GROUP)
-        end
-
-        it 'converts time and date traits into iso8601 format' do
-          client.identify({
-            :user_id => 'user',
-            :group_id => 'group',
-            :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),
-              :nottime => 'x'
-            }
-          })
-
-          message = queue.pop
-
-          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
-
-      describe '#page' do
-        it 'errors without user_id' do
-          expect { client.page :name => 'foo' }.to raise_error(ArgumentError)
-        end
-
-        it 'does not error with the required options' do
-          expect { client.page Queued::PAGE }.to_not raise_error
-        end
-
-        it 'does not error with the required options as strings' do
-          expect do
-            client.page Utils.stringify_keys(Queued::PAGE)
-          end.to_not raise_error
-        end
-      end
-
-      describe '#screen' do
-        it 'errors without user_id' do
-          expect { client.screen :name => 'foo' }.to raise_error(ArgumentError)
-        end
-
-        it 'does not error with the required options' do
-          expect { client.screen Queued::SCREEN }.to_not raise_error
-        end
-
-        it 'does not error with the required options as strings' do
-          expect do
-            client.screen Utils.stringify_keys(Queued::SCREEN)
-          end.to_not raise_error
-        end
-      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_with_worker.identify Queued::IDENTIFY
-          client_with_worker.track Queued::TRACK
-          client_with_worker.flush
-
-          expect(client_with_worker.queued_messages).to eq(0)
-        end
-
-        unless defined? JRUBY_VERSION
-          it 'completes when the process forks' do
-            client_with_worker.identify Queued::IDENTIFY
-
-            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
-        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' } }
-
-        it 'does not convert ids given as fixnums to strings' do
-          [:track, :screen, :page, :identify].each do |s|
-            client.send(s, data)
-            message = queue.pop(true)
-
-            expect(check_property.call(message, :userId, 1)).to eq(true)
-            expect(check_property.call(message, :anonymousId, 4)).to eq(true)
-          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)
-            message = queue.pop(true)
-
-            expect(check_property.call(message, :messageId, '5')).to eq(true)
-          end
-        end
-
-        context 'group' do
-          it 'does not convert ids given as fixnums to strings' do
-            client.group(data)
-            message = queue.pop(true)
-
-            expect(check_property.call(message, :userId, 1)).to eq(true)
-            expect(check_property.call(message, :groupId, 2)).to eq(true)
-          end
-        end
-
-        context 'alias' do
-          it 'does not convert ids given as fixnums to strings' do
-            client.alias(data)
-            message = queue.pop(true)
-
-            expect(check_property.call(message, :userId, 1)).to eq(true)
-            expect(check_property.call(message, :previousId, 3)).to eq(true)
-          end
-        end
-
-        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'
-            message = queue.pop(true)
-            expect(message[:integrations][:All]).to eq(true)
-            expect(message[:integrations][:Salesforce]).to eq(false)
-          end
-        end
-      end
-    end
-  end
-end