astronomer 2.0.14

data/lib/segment/analytics/defaults.rb

@@ -0,0 +1,20 @@
+module Segment
+  class Analytics
+    module Defaults
+      module Request
+        HOST = 'api.astronomer.io'
+        PORT = 443
+        PATH = '/v1/import'
+        SSL = true
+        HEADERS = { :accept => 'application/json' }
+        RETRIES = 4
+        BACKOFF = 30.0
+      end
+
+      module Queue
+        BATCH_SIZE = 100
+        MAX_SIZE = 10000
+      end
+    end
+  end
+end

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,82 @@
+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 app_id and batch of messages to the API.
+      #
+      # returns - Response of the status and error if it exists
+      def post(app_id, 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 app_id, nil
+
+          if self.class.stub
+            status = 200
+            error = nil
+            logger.debug "stubbed request to #{@path}: app id = #{app_id}, 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
+          unless (remaining_retries -=1).zero?
+            sleep(backoff)
+            retry
+          end
+
+          logger.error e.message
+          e.backtrace.each { |line| logger.error line }
+          status = -1
+          error = "Connection error: #{e}"
+        end
+
+        Response.new status, error
+      end
+
+      class << self
+        attr_accessor :stub
+
+        def stub
+          @stub || ENV['STUB']
+        end
+      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,88 @@
+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
+        case datetime
+        when Time
+            time_in_iso8601 datetime
+        when DateTime
+            time_in_iso8601 datetime.to_time
+        when Date
+          date_in_iso8601 datetime
+        else
+          datetime
+        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')}"
+      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 / 3600), ((seconds.abs % 3600) / 60)]
+      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,5 @@
+module Segment
+  class Analytics
+    VERSION = '2.0.13'
+  end
+end

data/lib/segment/analytics/worker.rb

@@ -0,0 +1,60 @@
+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
+      # app_id  - String of the project's app_id
+      # 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, app_id, options = {})
+        symbolize_keys! options
+        @queue = queue
+        @app_id = app_id
+        @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 @app_id, @batch
+
+          @lock.synchronize { @batch.clear }
+
+          @on_error.call res.status, res.error unless res.status == 200
+        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,302 @@
+require 'spec_helper'
+
+module Segment
+  class Analytics
+    describe Client do
+      let(:client) { Client.new :write_key => WRITE_KEY }
+      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
+
+          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')
+        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
+
+          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')
+        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
+        after do
+          client.flush
+        end
+
+        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
+
+          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')
+        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
+        it 'waits for the queue to finish on a flush' do
+          client.identify Queued::IDENTIFY
+          client.track Queued::TRACK
+          client.flush
+
+          expect(client.queued_messages).to eq(0)
+        end
+
+        it 'completes when the process forks' do
+          client.identify Queued::IDENTIFY
+
+          Process.fork do
+            client.track Queued::TRACK
+            client.flush
+            expect(client.queued_messages).to eq(0)
+          end
+
+          Process.wait
+        end unless defined? JRUBY_VERSION
+      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, :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
+
+        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