analytics-ruby 1.1.0 → 2.0.1

data/lib/analytics-ruby/consumer.rb

@@ -1,76 +0,0 @@
-
-require 'analytics-ruby/defaults'
-require 'analytics-ruby/request'
-require 'analytics-ruby/util'
-
-module AnalyticsRuby
-
-  class Consumer
-
-    # public: Creates a new consumer
-    #
-    # The consumer continuously takes messages off the queue
-    # and makes requests to the segment.io api
-    #
-    # queue   - Queue synchronized between client and consumer
-    # secret  - String of the project's secret
-    # options - Hash of consumer options
-    #           batch_size - Fixnum of how many items to send in a batch
-    #           on_error   - Proc of what to do on an error
-    #
-    def initialize(queue, secret, options = {})
-      Util.symbolize_keys! options
-
-      @queue = queue
-      @secret = secret
-      @batch_size = options[:batch_size] || Defaults::Queue::BATCH_SIZE
-      @on_error = options[:on_error] || Proc.new { |status, error| }
-
-      @current_batch = []
-
-      @mutex = Mutex.new
-    end
-
-    # public: Continuously runs the loop to check for new events
-    #
-    def run
-      until Thread.current[:should_exit]
-        flush
-      end
-    end
-
-    # public: Flush some events from our queue
-    #
-    def flush
-      # Block until we have something to send
-      item = @queue.pop
-      return if item.nil?
-
-      # Synchronize on additions to the current batch
-      @mutex.synchronize {
-        @current_batch << item
-        until @current_batch.length >= @batch_size || @queue.empty?
-          @current_batch << @queue.pop
-        end
-      }
-
-      req = Request.new
-      res = req.post @secret, @current_batch
-      @on_error.call res.status, res.error unless res.status == 200
-      @mutex.synchronize {
-        @current_batch = []
-      }
-    end
-
-    # public: Check whether we have outstanding requests.
-    #
-    def is_requesting?
-      requesting = nil
-      @mutex.synchronize {
-        requesting = !@current_batch.empty?
-      }
-      requesting
-    end
-
-  end
-end

data/lib/analytics-ruby/defaults.rb

@@ -1,21 +0,0 @@
-
-module AnalyticsRuby
-  module Defaults
-
-    module Request
-      HOST = 'api.segment.io' unless defined? AnalyticsRuby::Defaults::Request::HOST
-      PORT = 443 unless defined? AnalyticsRuby::Defaults::Request::PORT
-      PATH = '/v1/import' unless defined? AnalyticsRuby::Defaults::Request::PATH
-      SSL = true unless defined? AnalyticsRuby::Defaults::Request::SSL
-      HEADERS = { :accept => 'application/json' } unless defined? AnalyticsRuby::Defaults::Request::HEADERS
-      RETRIES = 4 unless defined? AnalyticsRuby::Defaults::Request::RETRIES
-      BACKOFF = 30.0 unless defined? AnalyticsRuby::Defaults::Request::BACKOFF
-    end
-
-    module Queue
-      BATCH_SIZE = 100 unless defined? AnalyticsRuby::Defaults::Queue::BATCH_SIZE
-      MAX_SIZE = 10000 unless defined? AnalyticsRuby::Defaults::Queue::MAX_SIZE
-    end
-
-  end
-end

data/lib/analytics-ruby/request.rb

@@ -1,61 +0,0 @@
-
-require 'analytics-ruby/defaults'
-require 'analytics-ruby/response'
-require 'net/http'
-require 'net/https'
-require 'json'
-
-module AnalyticsRuby
-
-  class Request
-
-    # public: Creates a new request object to send analytics batch
-    #
-    def initialize(options = {})
-      options[:host] ||= Defaults::Request::HOST
-      options[:port] ||= Defaults::Request::PORT
-      options[:ssl] ||= Defaults::Request::SSL
-      options[:headers] ||= Defaults::Request::HEADERS
-      @path = options[:path] || Defaults::Request::PATH
-      @retries = options[:retries] || Defaults::Request::RETRIES
-      @backoff = options[:backoff] || Defaults::Request::BACKOFF
-
-      http = Net::HTTP.new(options[:host], options[:port])
-      http.use_ssl = options[:ssl]
-      http.read_timeout = 8
-      http.open_timeout = 4
-
-      @http = http
-    end
-
-    # public: Posts the secret and batch of messages to the API.
-    #
-    # returns - Response of the status and error if it exists
-    def post(secret, batch)
-
-      status, error = nil, nil
-      remaining_retries = @retries
-      backoff = @backoff
-      headers = { 'Content-Type' => 'application/json', 'accept' => 'application/json' }
-      begin
-        payload = JSON.generate :secret => secret, :batch => batch
-        res = @http.request(Net::HTTP::Post.new(@path, headers), payload)
-        status = res.code.to_i
-        body = JSON.parse(res.body)
-        error = body["error"]
-
-      rescue Exception => err
-        puts "err: #{err}"
-        status = -1
-        error = "Connection error: #{err}"
-        puts "retries: #{remaining_retries}"
-        unless (remaining_retries -=1).zero?
-          sleep(backoff)
-          retry
-        end
-      end
-
-      Response.new status, error
-    end
-  end
-end

data/lib/analytics-ruby/response.rb

@@ -1,17 +0,0 @@
-
-module AnalyticsRuby
-
-  class Response
-
-    attr_reader :status
-    attr_reader :error
-
-    # public: Simple class to wrap responses from the API
-    #
-    #
-    def initialize(status = 200, error = nil)
-      @status = status
-      @error  = error
-    end
-  end
-end

data/lib/analytics-ruby/util.rb

@@ -1,42 +0,0 @@
-module Util
-
-  # public: Return a new hash with keys converted from strings to symbols
-  #
-  def self.symbolize_keys(hash)
-    hash.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
-  end
-
-  # public: Convert hash keys from strings to symbols in place
-  #
-  def self.symbolize_keys!(hash)
-    hash.replace symbolize_keys hash
-  end
-
-  # public: Return a new hash with keys as strings
-  #
-  def self.stringify_keys(hash)
-    hash.inject({}) { |memo, (k,v)| memo[k.to_s] = v; memo }
-  end
-
-  # public: Returns a new hash with all the date values in the into iso8601
-  #         strings
-  #
-  def self.isoify_dates(hash)
-    hash.inject({}) { |memo, (k, v)|
-      memo[k] = v.respond_to?(:iso8601) ? v.iso8601 : v
-      memo
-    }
-  end
-
-  # public: Converts all the date values in the into iso8601 strings in place
-  #
-  def self.isoify_dates!(hash)
-    hash.replace isoify_dates hash
-  end
-
-  # public: Returns a uid string
-  #
-  def self.uid
-    (0..16).to_a.map{|x| rand(16).to_s(16)}.join
-  end
-end

data/lib/analytics-ruby/version.rb

@@ -1,3 +0,0 @@
-module AnalyticsRuby
-  VERSION = '1.1.0'
-end

data/spec/client_spec.rb

@@ -1,212 +0,0 @@
-require 'analytics-ruby'
-require 'spec_helper'
-
-
-describe AnalyticsRuby::Client do
-
-  describe '#init' do
-
-    it 'should error if no secret is supplied' do
-      expect { AnalyticsRuby::Client.new }.to raise_error(RuntimeError)
-    end
-
-    it 'should not error if a secret is supplied' do
-      AnalyticsRuby::Client.new :secret => AnalyticsRubyHelpers::SECRET
-    end
-
-    it 'should not error if a secret is supplied as a string' do
-      AnalyticsRuby::Client.new 'secret' => AnalyticsRubyHelpers::SECRET
-    end
-  end
-
-  describe '#track' do
-
-    before(:all) do
-      @client = AnalyticsRuby::Client.new :secret => AnalyticsRubyHelpers::SECRET
-      @client.instance_variable_get(:@thread).kill
-      @queue = @client.instance_variable_get :@queue
-    end
-
-    it 'should error without an event' do
-      expect { @client.track(:user_id => 'user') }.to raise_error(ArgumentError)
-    end
-
-    it 'should error without a user_id' do
-      expect { @client.track(:event => 'Event') }.to raise_error(ArgumentError)
-    end
-
-    it 'should error 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 'should not error with the required options' do
-      @client.track AnalyticsRubyHelpers::Queued::TRACK
-      @queue.pop
-    end
-
-    it 'should not error when given string keys' do
-      @client.track Util.stringify_keys(AnalyticsRubyHelpers::Queued::TRACK)
-      @queue.pop
-    end
-
-    it 'should convert Time properties into iso8601 format' do
-      @client.track({
-        :user_id => 'user',
-        :event => 'Event',
-        :properties => {
-          :time => Time.utc(2013),
-          :nottime => 'x'
-        }
-      })
-      message = @queue.pop
-      message[:properties][:time].should == '2013-01-01T00:00:00Z'
-      message[:properties][:nottime].should == 'x'
-    end
-  end
-
-
-  describe '#identify' do
-
-    before(:all) do
-      @client = AnalyticsRuby::Client.new :secret => AnalyticsRubyHelpers::SECRET
-      @client.instance_variable_get(:@thread).kill
-      @queue = @client.instance_variable_get :@queue
-    end
-
-    it 'should error without any user id' do
-      expect { @client.identify({}) }.to raise_error(ArgumentError)
-    end
-
-    it 'should not error with the required options' do
-      @client.identify AnalyticsRubyHelpers::Queued::IDENTIFY
-      @queue.pop
-    end
-
-    it 'should not error with the required options as strings' do
-      @client.identify Util.stringify_keys(AnalyticsRubyHelpers::Queued::IDENTIFY)
-      @queue.pop
-    end
-
-    it 'should convert Time traits into iso8601 format' do
-      @client.identify({
-        :user_id => 'user',
-        :traits => {
-          :time => Time.utc(2013),
-          :nottime => 'x'
-        }
-      })
-      message = @queue.pop
-      message[:traits][:time].should == '2013-01-01T00:00:00Z'
-      message[:traits][:nottime].should == 'x'
-    end
-  end
-
-  describe '#alias' do
-    before :all do
-      @client = AnalyticsRuby::Client.new :secret => AnalyticsRubyHelpers::SECRET
-    end
-
-    it 'should error without from' do
-      expect { @client.alias :to => 1234 }.to raise_error(ArgumentError)
-    end
-
-    it 'should error without to' do
-      expect { @client.alias :from => 1234 }.to raise_error(ArgumentError)
-    end
-
-    it 'should not error with the required options' do
-      @client.alias AnalyticsRubyHelpers::ALIAS
-    end
-
-    it 'should not error with the required options as strings' do
-      @client.alias Util.stringify_keys(AnalyticsRubyHelpers::ALIAS)
-    end
-  end
-
-  describe '#group' do
-    before :all do
-      @client = AnalyticsRuby::Client.new :secret => AnalyticsRubyHelpers::SECRET
-    end
-
-    it 'should error without group_id' do
-      expect { @client.group :user_id => 'foo' }.to raise_error(ArgumentError)
-    end
-
-    it 'should error without user_id' do
-      expect { @client.group :group_id => 'foo' }.to raise_error(ArgumentError)
-    end
-
-    it 'should not error with the required options' do
-      @client.group AnalyticsRubyHelpers::Queued::GROUP
-    end
-
-    it 'should not error with the required options as strings' do
-      @client.group Util.stringify_keys(AnalyticsRubyHelpers::Queued::GROUP)
-    end
-  end
-
-  describe '#page' do
-    before :all do
-      @client = AnalyticsRuby::Client.new :secret => AnalyticsRubyHelpers::SECRET
-    end
-
-    it 'should error without user_id' do
-      expect { @client.page :name => 'foo' }.to raise_error(ArgumentError)
-    end
-
-    it 'should error without name' do
-      expect { @client.page :user_id => 1 }.to raise_error(ArgumentError)
-    end
-
-    it 'should not error with the required options' do
-      @client.page AnalyticsRubyHelpers::Queued::PAGE
-    end
-
-    it 'should not error with the required options as strings' do
-      @client.page Util.stringify_keys(AnalyticsRubyHelpers::Queued::PAGE)
-    end
-  end
-
-  describe '#screen' do
-    before :all do
-      @client = AnalyticsRuby::Client.new :secret => AnalyticsRubyHelpers::SECRET
-    end
-
-    it 'should error without user_id' do
-      expect { @client.screen :name => 'foo' }.to raise_error(ArgumentError)
-    end
-
-    it 'should error without name' do
-      expect { A@client.screen :user_id => 1 }.to raise_error(ArgumentError)
-    end
-
-    it 'should not error with the required options' do
-      @client.screen AnalyticsRubyHelpers::Queued::SCREEN
-    end
-
-    it 'should not error with the required options as strings' do
-      @client.screen Util.stringify_keys(AnalyticsRubyHelpers::Queued::SCREEN)
-    end
-  end
-
-  describe '#flush' do
-    before(:all) do
-      @client = AnalyticsRuby::Client.new :secret => AnalyticsRubyHelpers::SECRET
-    end
-
-    it 'should wait for the queue to finish on a flush' do
-      @client.identify AnalyticsRubyHelpers::Queued::IDENTIFY
-      @client.track AnalyticsRubyHelpers::Queued::TRACK
-      @client.flush
-      @client.queued_messages.should == 0
-    end
-  end
-end
-
-

data/spec/consumer_spec.rb

@@ -1,103 +0,0 @@
-require 'analytics-ruby'
-require 'thread'
-require 'spec_helper'
-
-describe AnalyticsRuby::Consumer do
-
-  describe "#init" do
-    it 'accepts string keys' do
-      queue = Queue.new
-      consumer = AnalyticsRuby::Consumer.new(queue, 'secret', 'batch_size' => 100)
-      consumer.instance_variable_get(:@batch_size).should == 100
-    end
-  end
-
-  describe '#flush' do
-
-    before :all do
-      AnalyticsRuby::Defaults::Request::BACKOFF = 0.1
-    end
-
-    after :all do
-      AnalyticsRuby::Defaults::Request::BACKOFF = 30.0
-    end
-
-    it 'should not error if the endpoint is unreachable' do
-
-      Net::HTTP.any_instance.stub(:post).and_raise(Exception)
-
-      queue = Queue.new
-      queue << {}
-      consumer = AnalyticsRuby::Consumer.new(queue, 'secret')
-      consumer.flush
-
-      queue.should be_empty
-
-      Net::HTTP.any_instance.unstub(:post)
-    end
-
-    it 'should execute the error handler if the request is invalid' do
-
-      AnalyticsRuby::Request.any_instance.stub(:post).and_return(
-        AnalyticsRuby::Response.new(400, "Some error"))
-
-      on_error = Proc.new do |status, error|
-        puts "#{status}, #{error}"
-      end
-
-      on_error.should_receive(:call).once
-
-      queue = Queue.new
-      queue << {}
-      consumer = AnalyticsRuby::Consumer.new queue, 'secret', :on_error => on_error
-      consumer.flush
-
-      AnalyticsRuby::Request::any_instance.unstub(:post)
-
-      queue.should be_empty
-    end
-
-    it 'should not call on_error if the request is good' do
-
-      on_error = Proc.new do |status, error|
-        puts "#{status}, #{error}"
-      end
-
-      on_error.should_receive(:call).at_most(0).times
-
-      queue = Queue.new
-      queue << AnalyticsRubyHelpers::Requested::TRACK
-      consumer = AnalyticsRuby::Consumer.new queue, 'testsecret', :on_error => on_error
-      consumer.flush
-
-      queue.should be_empty
-    end
-  end
-
-  describe '#is_requesting?' do
-
-    it 'should not return true if there isn\'t a current batch' do
-
-      queue = Queue.new
-      consumer = AnalyticsRuby::Consumer.new(queue, 'testsecret')
-
-      consumer.is_requesting?.should == false
-    end
-
-    it 'should return true if there is a current batch' do
-
-      queue = Queue.new
-      queue << AnalyticsRubyHelpers::Requested::TRACK
-      consumer = AnalyticsRuby::Consumer.new(queue, 'testsecret')
-
-      Thread.new {
-        consumer.flush
-        consumer.is_requesting?.should == false
-      }
-
-      # sleep barely long enough to let thread flush the queue.
-      sleep(0.001)
-      consumer.is_requesting?.should == true
-    end
-  end
-end