analytics-ruby 1.1.0 → 2.0.1

data/lib/segment/analytics/logging.rb

@@ -0,0 +1,35 @@
+require 'logger'
+
+module Segment
+  class Analytics
+    module Logging
+      class << self
+        def logger
+          @logger ||= if defined?(Rails)
+                        Rails.logger
+                      else
+                        logger = Logger.new STDOUT
+                        logger.progname = 'Segment::Analytics'
+                        logger
+                      end
+        end
+
+        def logger= logger
+          @logger = logger
+        end
+      end
+
+      def self.included base
+        class << base
+          def logger
+            Logging.logger
+          end
+        end
+      end
+
+      def logger
+        Logging.logger
+      end
+    end
+  end
+end

data/lib/segment/analytics/request.rb

@@ -0,0 +1,80 @@
+require 'segment/analytics/defaults'
+require 'segment/analytics/utils'
+require 'segment/analytics/response'
+require 'segment/analytics/logging'
+require 'net/http'
+require 'net/https'
+require 'json'
+
+module Segment
+  class Analytics
+    class Request
+      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
+        options[:ssl] ||= SSL
+        options[:headers] ||= HEADERS
+        @path = options[:path] || PATH
+        @retries = options[:retries] || RETRIES
+        @backoff = options[:backoff] || 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 write key and batch of messages to the API.
+      #
+      # returns - Response of the status and error if it exists
+      def post(write_key, batch)
+        status, error = nil, nil
+        remaining_retries = @retries
+        backoff = @backoff
+        headers = { 'Content-Type' => 'application/json', 'accept' => 'application/json' }
+        begin
+          payload = JSON.generate :sentAt => datetime_in_iso8601(Time.new), :batch => batch
+          request = Net::HTTP::Post.new(@path, headers)
+          request.basic_auth write_key, nil
+
+          if self.class.stub
+            status = 200
+            error = nil
+            logger.debug "stubbed request to #{@path}: write key = #{write_key}, payload = #{payload}"
+          else
+            res = @http.request(request, payload)
+            status = res.code.to_i
+            body = JSON.parse(res.body)
+            error = body["error"]
+          end
+
+        rescue Exception => e
+          logger.error e.message
+          e.backtrace.each { |line| logger.error line }
+          status = -1
+          error = "Connection error: #{e}"
+          logger.info "retries remaining: #{remaining_retries}"
+
+          unless (remaining_retries -=1).zero?
+            sleep(backoff)
+            retry
+          end
+        end
+
+        Response.new status, error
+      end
+
+      class << self
+        attr_accessor :stub
+      end
+    end
+  end
+end

data/lib/segment/analytics/response.rb

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

data/lib/segment/analytics/utils.rb

@@ -0,0 +1,85 @@
+require 'securerandom'
+
+module Segment
+  class Analytics
+    module Utils
+      extend self
+
+      # public: Return a new hash with keys converted from strings to symbols
+      #
+      def 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 symbolize_keys!(hash)
+        hash.replace symbolize_keys hash
+      end
+
+      # public: Return a new hash with keys as strings
+      #
+      def 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 isoify_dates(hash)
+        hash.inject({}) { |memo, (k, v)|
+          memo[k] = datetime_in_iso8601(v)
+          memo
+        }
+      end
+
+      # public: Converts all the date values in the into iso8601 strings in place
+      #
+      def isoify_dates!(hash)
+        hash.replace isoify_dates hash
+      end
+
+      # public: Returns a uid string
+      #
+      def uid
+        arr = SecureRandom.random_bytes(16).unpack("NnnnnN")
+        arr[2] = (arr[2] & 0x0fff) | 0x4000
+        arr[3] = (arr[3] & 0x3fff) | 0x8000
+        "%08x-%04x-%04x-%04x-%04x%08x" % arr
+      end
+
+      def datetime_in_iso8601 datetime
+        if datetime.is_a? Date
+          date_in_iso8601 datetime
+        elsif datetime.is_a? Time
+          time_in_iso8601 datetime
+        else
+          datetime
+        end
+      end
+
+      def time_in_iso8601 time, fraction_digits = 0
+        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')}"
+      end
+
+      def date_in_iso8601 date
+        date.strftime("%F")
+      end
+
+      def formatted_offset time, colon = true, alternate_utc_string = nil
+        time.utc? && alternate_utc_string || seconds_to_utc_offset(time.utc_offset, colon)
+      end
+
+      def seconds_to_utc_offset(seconds, colon = true)
+        (colon ? UTC_OFFSET_WITH_COLON : UTC_OFFSET_WITHOUT_COLON) % [(seconds < 0 ? '-' : '+'), seconds.abs, (seconds.abs % 3600)]
+      end
+
+      UTC_OFFSET_WITH_COLON = '%s%02d:%02d'
+      UTC_OFFSET_WITHOUT_COLON = UTC_OFFSET_WITH_COLON.sub(':', '')
+    end
+  end
+end

data/lib/segment/analytics/version.rb

@@ -0,0 +1,6 @@
+module Segment
+  class Analytics
+    VERSION = '2.0.1'
+  end
+end
+

data/lib/segment/analytics/worker.rb

@@ -0,0 +1,59 @@
+require 'segment/analytics/defaults'
+require 'segment/analytics/utils'
+require 'segment/analytics/defaults'
+require 'segment/analytics/request'
+
+module Segment
+  class Analytics
+    class Worker
+      include Segment::Analytics::Utils
+      include Segment::Analytics::Defaults
+
+      # public: Creates a new worker
+      #
+      # The worker continuously takes messages off the queue
+      # and makes requests to the segment.io api
+      #
+      # queue   - Queue synchronized between client and worker
+      # write_key  - String of the project's Write key
+      # options - Hash of worker 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, write_key, options = {})
+        symbolize_keys! options
+        @queue = queue
+        @write_key = write_key
+        @batch_size = options[:batch_size] || Queue::BATCH_SIZE
+        @on_error = options[:on_error] || Proc.new { |status, error| }
+        @batch = []
+        @lock = Mutex.new
+      end
+
+      # public: Continuously runs the loop to check for new events
+      #
+      def run
+        until Thread.current[:should_exit]
+          return if @queue.empty?
+
+          @lock.synchronize do
+            until @batch.length >= @batch_size || @queue.empty?
+              @batch << @queue.pop
+            end
+          end
+
+          res = Request.new.post @write_key, @batch
+          @on_error.call res.status, res.error unless res.status == 200
+
+          @lock.synchronize { @batch.clear }
+        end
+      end
+
+      # public: Check whether we have outstanding requests.
+      #
+      def is_requesting?
+        @lock.synchronize { !@batch.empty? }
+      end
+    end
+  end
+end

data/spec/segment/analytics/client_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe Client do
+      describe '#initialize' do
+        it 'should error if no write_key is supplied' do
+          expect { Client.new }.to raise_error(ArgumentError)
+        end
+
+        it 'should not error if a write_key is supplied' do
+          Client.new :write_key => WRITE_KEY
+        end
+
+        it 'should not error if a write_key is supplied as a string' do
+          Client.new 'write_key' => WRITE_KEY
+        end
+      end
+
+      describe '#track' do
+        before(:all) do
+          @client = Client.new :write_key => WRITE_KEY
+          @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 Queued::TRACK
+          @queue.pop
+        end
+
+        it 'should not error when given string keys' do
+          @client.track Utils.stringify_keys(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 = Client.new :write_key => WRITE_KEY
+          @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 Queued::IDENTIFY
+          @queue.pop
+        end
+
+        it 'should not error with the required options as strings' do
+          @client.identify Utils.stringify_keys(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 = Client.new :write_key => WRITE_KEY
+        end
+
+        it 'should error without from' do
+          expect { @client.alias :user_id => 1234 }.to raise_error(ArgumentError)
+        end
+
+        it 'should error without to' do
+          expect { @client.alias :previous_id => 1234 }.to raise_error(ArgumentError)
+        end
+
+        it 'should not error with the required options' do
+          @client.alias ALIAS
+        end
+
+        it 'should not error with the required options as strings' do
+          @client.alias Utils.stringify_keys(ALIAS)
+        end
+      end
+
+      describe '#group' do
+        before :all do
+          @client = Client.new :write_key => WRITE_KEY
+        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 Queued::GROUP
+        end
+
+        it 'should not error with the required options as strings' do
+          @client.group Utils.stringify_keys(Queued::GROUP)
+        end
+      end
+
+      describe '#page' do
+        before :all do
+          @client = Client.new :write_key => WRITE_KEY
+        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 Queued::PAGE
+        end
+
+        it 'should not error with the required options as strings' do
+          @client.page Utils.stringify_keys(Queued::PAGE)
+        end
+      end
+
+      describe '#screen' do
+        before :all do
+          @client = Client.new :write_key => WRITE_KEY
+        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 Queued::SCREEN
+        end
+
+        it 'should not error with the required options as strings' do
+          @client.screen Utils.stringify_keys(Queued::SCREEN)
+        end
+      end
+
+      describe '#flush' do
+        before(:all) do
+          @client = Client.new :write_key => WRITE_KEY
+        end
+
+        it 'should wait for the queue to finish on a flush' do
+          @client.identify Queued::IDENTIFY
+          @client.track Queued::TRACK
+          @client.flush
+          @client.queued_messages.should == 0
+        end
+
+        it 'should complete when the process forks' do
+          @client.identify Queued::IDENTIFY
+
+          Process.fork do
+            @client.track Queued::TRACK
+            @client.flush
+            @client.queued_messages.should == 0
+          end
+
+          Process.wait
+        end unless defined? JRUBY_VERSION
+      end
+
+      context 'common' do
+        check_property = proc { |msg, k, v| msg[k] && msg[k].should == v } 
+
+        before(:all) do
+          @client = Client.new :write_key => WRITE_KEY
+          @queue = @client.instance_variable_get :@queue
+        end
+
+
+        it 'should not convert ids given as fixnums to strings' do
+          [:track, :screen, :page, :group, :identify, :alias].each do |s|
+            @client.send s, :user_id => 1, :group_id => 2, :previous_id => 3, :anonymous_id => 4, :event => "coco barked", :name => "coco"
+            message = @queue.pop(true)
+            check_property.call(message, :userId, 1)
+            check_property.call(message, :groupId, 2)
+            check_property.call(message, :previousId, 3)
+            check_property.call(message, :anonymousId, 4)
+          end
+        end
+
+        it 'should send 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)
+            message[:integrations][:All].should be_true
+            message[:integrations][:Salesforce].should be_false
+          end
+        end
+      end
+    end
+  end
+end