ruddertest 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53dcdb06e2e9577a5b366836dcb2bde0feb01b00
+  data.tar.gz: 7d64fadf5adfb060f0a8e63ed08a5165d41c3ddb
+SHA512:
+  metadata.gz: 80f085f8d74998a3ffd739e75dc1d86fe6e1d890fbbed24437e7cb27fed5594b963dccd45be26ea4ef47f6011bad68ed35ba24c07c7e35b11e2142d42c3ca411
+  data.tar.gz: b58b5baad9de35c590aebd8232bc98a86938a9fcb5649f94005f03a0a9c59f48035527f395019ebf8004847d5c5c31944591867e721cad4d05cfdd0ebb2d05a5

data/bin/analytics

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+require 'segment/analytics'
+require 'rubygems'
+require 'commander/import'
+require 'time'
+require 'json'
+
+program :name, 'simulator.rb'
+program :version, '0.0.1'
+program :description, 'scripting simulator'
+
+def json_hash(str)
+  if str
+    return JSON.parse(str)
+  end
+end
+
+# analytics -method=<method> -segment-write-key=<segmentWriteKey> [options]
+
+default_command :send
+
+command :send do |c|
+  c.description = 'send a segment message'
+
+  c.option '--writeKey=<writeKey>', String, 'the Rudder writeKey'
+  c.option '--dataPlaneUrl=<dataPlaneUrl>', String, 'the Rudder data plane URL'
+  c.option '--type=<type>', String, 'The Segment message type'
+
+  c.option '--userId=<userId>', String, 'the user id to send the event as'
+  c.option '--anonymousId=<anonymousId>', String, 'the anonymous user id to send the event as'
+  c.option '--context=<context>', 'additional context for the event (JSON-encoded)'
+  c.option '--integrations=<integrations>', 'additional integrations for the event (JSON-encoded)'
+
+  c.option '--event=<event>', String, 'the event name to send with the event'
+  c.option '--properties=<properties>', 'the event properties to send (JSON-encoded)'
+
+  c.option '--name=<name>', 'name of the screen or page to send with the message'
+
+  c.option '--traits=<traits>', 'the identify/group traits to send (JSON-encoded)'
+
+  c.option '--groupId=<groupId>', String, 'the group id'
+  c.option '--previousId=<previousId>', String, 'the previous id'
+
+  c.action do |args, options|
+    Analytics = Segment::Analytics.new({
+      write_key: options.writeKey,
+      data_plane_url: options.dataPlaneUrl,
+      on_error: Proc.new { |status, msg| print msg }
+    })
+
+    case options.type
+    when "track"
+      Analytics.track({
+        user_id: options.userId,
+        event: options.event,
+        anonymous_id: options.anonymousId,
+        properties: json_hash(options.properties),
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
+      })
+    when "page"
+      Analytics.page({
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        name: options.name,
+        properties: json_hash(options.properties),
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
+      })
+    when "screen"
+      Analytics.screen({
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        name: options.name,
+        properties: json_hash(options.properties),
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
+      })
+    when "identify"
+      Analytics.identify({
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        traits: json_hash(options.traits),
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
+      })
+    when "group"
+      Analytics.group({
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        group_id: options.groupId,
+        traits: json_hash(options.traits),
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
+      })
+    when "alias"
+      Analytics.alias({
+        previous_id: options.previousId,
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        context: json_hash(options.context),
+        integrations: json_hash(options.integrations)
+      })
+    else
+      raise "Invalid Message Type #{options.type}"
+    end
+    Analytics.flush
+  end
+end

data/lib/analytics-ruby.rb

@@ -0,0 +1 @@
+require 'segment'

data/lib/segment/analytics/backoff_policy.rb

@@ -0,0 +1,49 @@
+require 'segment/analytics/defaults'
+
+module Segment
+  class Analytics
+    class BackoffPolicy
+      include Segment::Analytics::Defaults::BackoffPolicy
+
+      # @param [Hash] opts
+      # @option opts [Numeric] :min_timeout_ms The minimum backoff timeout
+      # @option opts [Numeric] :max_timeout_ms The maximum backoff timeout
+      # @option opts [Numeric] :multiplier The value to multiply the current
+      #   interval with for each retry attempt
+      # @option opts [Numeric] :randomization_factor The randomization factor
+      #   to use to create a range around the retry interval
+      def initialize(opts = {})
+        @min_timeout_ms = opts[:min_timeout_ms] || MIN_TIMEOUT_MS
+        @max_timeout_ms = opts[:max_timeout_ms] || MAX_TIMEOUT_MS
+        @multiplier = opts[:multiplier] || MULTIPLIER
+        @randomization_factor = opts[:randomization_factor] || RANDOMIZATION_FACTOR
+
+        @attempts = 0
+      end
+
+      # @return [Numeric] the next backoff interval, in milliseconds.
+      def next_interval
+        interval = @min_timeout_ms * (@multiplier**@attempts)
+        interval = add_jitter(interval, @randomization_factor)
+
+        @attempts += 1
+
+        [interval, @max_timeout_ms].min
+      end
+
+      private
+
+      def add_jitter(base, randomization_factor)
+        random_number = rand
+        max_deviation = base * randomization_factor
+        deviation = random_number * max_deviation
+
+        if random_number < 0.5
+          base - deviation
+        else
+          base + deviation
+        end
+      end
+    end
+  end
+end

data/lib/segment/analytics/client.rb

@@ -0,0 +1,193 @@
+require 'thread'
+require 'time'
+
+require 'segment/analytics/defaults'
+require 'segment/analytics/logging'
+require 'segment/analytics/utils'
+require 'segment/analytics/worker'
+require 'segment/analytics/defaults'
+
+module Segment
+  class Analytics
+    class Client
+      include Segment::Analytics::Utils
+      include Segment::Analytics::Logging
+
+      # @param [Hash] opts
+      # @option opts [String] :write_key Your project's write_key
+      # @option opts [String] :data_plane_url Your data plane URL
+      # @option opts [FixNum] :max_queue_size Maximum number of calls to be
+      #   remain queued.
+      # @option opts [Proc] :on_error Handles error calls from the API.
+      def initialize(opts = {})
+        symbolize_keys!(opts)
+
+        @queue = Queue.new
+        @write_key = opts[:write_key]
+        @data_plane_url = opts[:data_plane_url]
+        @max_queue_size = opts[:max_queue_size] || Defaults::Queue::MAX_SIZE
+        @worker_mutex = Mutex.new
+        @worker = Worker.new(@queue, @data_plane_url, @write_key, opts)
+        @worker_thread = nil
+
+        check_write_key!
+
+        at_exit { @worker_thread && @worker_thread[:should_exit] = true }
+      end
+
+      # Synchronously waits until the worker has flushed the queue.
+      #
+      # Use only for scripts which are not long-running, and will specifically
+      # exit
+      def flush
+        while !@queue.empty? || @worker.is_requesting?
+          ensure_worker_running
+          sleep(0.1)
+        end
+      end
+
+      # @!macro common_attrs
+      #   @option attrs [String] :anonymous_id ID for a user when you don't know
+      #     who they are yet. (optional but you must provide either an
+      #     `anonymous_id` or `user_id`)
+      #   @option attrs [Hash] :context ({})
+      #   @option attrs [Hash] :integrations What integrations this event
+      #     goes to (optional)
+      #   @option attrs [String] :message_id ID that uniquely
+      #     identifies a message across the API. (optional)
+      #   @option attrs [Time] :timestamp When the event occurred (optional)
+      #   @option attrs [String] :user_id The ID for this user in your database
+      #     (optional but you must provide either an `anonymous_id` or `user_id`)
+      #   @option attrs [Hash] :options Options such as user traits (optional)
+
+      # Tracks an event
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#track
+      #
+      # @param [Hash] attrs
+      #
+      # @option attrs [String] :event Event name
+      # @option attrs [Hash] :properties Event properties (optional)
+      # @macro common_attrs
+      def track(attrs)
+        symbolize_keys! attrs
+        enqueue(FieldParser.parse_for_track(attrs))
+      end
+
+      # Identifies a user
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#identify
+      #
+      # @param [Hash] attrs
+      #
+      # @option attrs [Hash] :traits User traits (optional)
+      # @macro common_attrs
+      def identify(attrs)
+        symbolize_keys! attrs
+        enqueue(FieldParser.parse_for_identify(attrs))
+      end
+
+      # Aliases a user from one id to another
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#alias
+      #
+      # @param [Hash] attrs
+      #
+      # @option attrs [String] :previous_id The ID to alias from
+      # @macro common_attrs
+      def alias(attrs)
+        symbolize_keys! attrs
+        enqueue(FieldParser.parse_for_alias(attrs))
+      end
+
+      # Associates a user identity with a group.
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#group
+      #
+      # @param [Hash] attrs
+      #
+      # @option attrs [String] :group_id The ID of the group
+      # @option attrs [Hash] :traits User traits (optional)
+      # @macro common_attrs
+      def group(attrs)
+        symbolize_keys! attrs
+        enqueue(FieldParser.parse_for_group(attrs))
+      end
+
+      # Records a page view
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#page
+      #
+      # @param [Hash] attrs
+      #
+      # @option attrs [String] :name Name of the page
+      # @option attrs [Hash] :properties Page properties (optional)
+      # @macro common_attrs
+      def page(attrs)
+        symbolize_keys! attrs
+        enqueue(FieldParser.parse_for_page(attrs))
+      end
+
+      # Records a screen view (for a mobile app)
+      #
+      # @param [Hash] attrs
+      #
+      # @option attrs [String] :name Name of the screen
+      # @option attrs [Hash] :properties Screen properties (optional)
+      # @option attrs [String] :category The screen category (optional)
+      # @macro common_attrs
+      def screen(attrs)
+        symbolize_keys! attrs
+        enqueue(FieldParser.parse_for_screen(attrs))
+      end
+
+      # @return [Fixnum] number of messages in the queue
+      def queued_messages
+        @queue.length
+      end
+
+      private
+
+      # private: Enqueues the action.
+      #
+      # returns Boolean of whether the item was added to the queue.
+      def enqueue(action)
+        # add our request id for tracing purposes
+        action[:messageId] ||= uid
+
+        if @queue.length < @max_queue_size
+          @queue << action
+          ensure_worker_running
+
+          true
+        else
+          logger.warn(
+            'Queue is full, dropping events. The :max_queue_size ' \
+            'configuration parameter can be increased to prevent this from ' \
+            'happening.'
+          )
+          false
+        end
+      end
+
+      # private: Checks that the write_key is properly initialized
+      def check_write_key!
+        raise ArgumentError, 'Write key must be initialized' if @write_key.nil?
+      end
+
+      def ensure_worker_running
+        return if worker_running?
+        @worker_mutex.synchronize do
+          return if worker_running?
+          @worker_thread = Thread.new do
+            @worker.run
+          end
+        end
+      end
+
+      def worker_running?
+        @worker_thread && @worker_thread.alive?
+      end
+    end
+  end
+end

data/lib/segment/analytics/defaults.rb

@@ -0,0 +1,36 @@
+module Segment
+  class Analytics
+    module Defaults
+      module Request
+        HOST = 'api.segment.io'
+        PORT = 443
+        PATH = '/v1/import'
+        SSL = true
+        HEADERS = { 'Accept' => 'application/json',
+                    'Content-Type' => 'application/json',
+                    'User-Agent' => "analytics-ruby/#{Analytics::VERSION}" }
+        RETRIES = 10
+      end
+
+      module Queue
+        MAX_SIZE = 10000
+      end
+
+      module Message
+        MAX_BYTES = 32768 # 32Kb
+      end
+
+      module MessageBatch
+        MAX_BYTES = 512_000 # 500Kb
+        MAX_SIZE = 100
+      end
+
+      module BackoffPolicy
+        MIN_TIMEOUT_MS = 100
+        MAX_TIMEOUT_MS = 10000
+        MULTIPLIER = 1.5
+        RANDOMIZATION_FACTOR = 0.5
+      end
+    end
+  end
+end

data/lib/segment/analytics/field_parser.rb

@@ -0,0 +1,192 @@
+module Segment
+  class Analytics
+    # Handles parsing fields according to the Segment Spec
+    #
+    # @see https://segment.com/docs/spec/
+    class FieldParser
+      class << self
+        include Segment::Analytics::Utils
+
+        # In addition to the common fields, track accepts:
+        #
+        # - "event"
+        # - "properties"
+        def parse_for_track(fields)
+          common = parse_common_fields(fields)
+
+          event = fields[:event]
+          properties = fields[:properties] || {}
+
+          check_presence!(event, 'event')
+          check_is_hash!(properties, 'properties')
+
+          isoify_dates! properties
+
+          common.merge({
+            :type => 'track',
+            :event => event.to_s,
+            :properties => properties
+          })
+        end
+
+        # In addition to the common fields, identify accepts:
+        #
+        # - "traits"
+        def parse_for_identify(fields)
+          common = parse_common_fields(fields)
+
+          traits = fields[:traits] || {}
+          check_is_hash!(traits, 'traits')
+          isoify_dates! traits
+
+          common.merge({
+            :type => 'identify',
+            :traits => traits
+          })
+        end
+
+        # In addition to the common fields, alias accepts:
+        #
+        # - "previous_id"
+        def parse_for_alias(fields)
+          common = parse_common_fields(fields)
+
+          previous_id = fields[:previous_id]
+          check_presence!(previous_id, 'previous_id')
+
+          common.merge({
+            :type => 'alias',
+            :previousId => previous_id
+          })
+        end
+
+        # In addition to the common fields, group accepts:
+        #
+        # - "group_id"
+        # - "traits"
+        def parse_for_group(fields)
+          common = parse_common_fields(fields)
+
+          group_id = fields[:group_id]
+          traits = fields[:traits] || {}
+
+          check_presence!(group_id, 'group_id')
+          check_is_hash!(traits, 'traits')
+
+          isoify_dates! traits
+
+          common.merge({
+            :type => 'group',
+            :groupId => group_id,
+            :traits => traits
+          })
+        end
+
+        # In addition to the common fields, page accepts:
+        #
+        # - "name"
+        # - "properties"
+        def parse_for_page(fields)
+          common = parse_common_fields(fields)
+
+          name = fields[:name] || ''
+          properties = fields[:properties] || {}
+
+          check_is_hash!(properties, 'properties')
+
+          isoify_dates! properties
+
+          common.merge({
+            :type => 'page',
+            :name => name.to_s,
+            :properties => properties
+          })
+        end
+
+        # In addition to the common fields, screen accepts:
+        #
+        # - "name"
+        # - "properties"
+        # - "category" (Not in spec, retained for backward compatibility"
+        def parse_for_screen(fields)
+          common = parse_common_fields(fields)
+
+          name = fields[:name]
+          properties = fields[:properties] || {}
+          category = fields[:category]
+
+          check_presence!(name, 'name')
+          check_is_hash!(properties, 'properties')
+
+          isoify_dates! properties
+
+          parsed = common.merge({
+            :type => 'screen',
+            :name => name,
+            :properties => properties
+          })
+
+          parsed[:category] = category if category
+
+          parsed
+        end
+
+        private
+
+        def parse_common_fields(fields)
+          timestamp = fields[:timestamp] || Time.new
+          message_id = fields[:message_id].to_s if fields[:message_id]
+          context = fields[:context] || {}
+
+          check_user_id! fields
+          check_timestamp! timestamp
+
+          add_context! context
+
+          parsed = {
+            :context => context,
+            :messageId => message_id,
+            :timestamp => datetime_in_iso8601(timestamp)
+          }
+
+          parsed[:userId] = fields[:user_id] if fields[:user_id]
+          parsed[:anonymousId] = fields[:anonymous_id] if fields[:anonymous_id]
+          parsed[:integrations] = fields[:integrations] if fields[:integrations]
+
+          # Not in spec, retained for backward compatibility
+          parsed[:options] = fields[:options] if fields[:options]
+
+          parsed
+        end
+
+        def check_user_id!(fields)
+          unless fields[:user_id] || fields[:anonymous_id]
+            raise ArgumentError, 'Must supply either user_id or anonymous_id'
+          end
+        end
+
+        def check_timestamp!(timestamp)
+          raise ArgumentError, 'Timestamp must be a Time' unless timestamp.is_a? Time
+        end
+
+        def add_context!(context)
+          context[:library] = { :name => 'analytics-ruby', :version => Segment::Analytics::VERSION.to_s }
+        end
+
+        # private: Ensures that a string is non-empty
+        #
+        # obj    - String|Number that must be non-blank
+        # name   - Name of the validated value
+        def check_presence!(obj, name)
+          if obj.nil? || (obj.is_a?(String) && obj.empty?)
+            raise ArgumentError, "#{name} must be given"
+          end
+        end
+
+        def check_is_hash!(obj, name)
+          raise ArgumentError, "#{name} must be a Hash" unless obj.is_a? Hash
+        end
+      end
+    end
+  end
+end

data/lib/segment/analytics/logging.rb

@@ -0,0 +1,60 @@
+require 'logger'
+
+module Segment
+  class Analytics
+    # Wraps an existing logger and adds a prefix to all messages
+    class PrefixedLogger
+      def initialize(logger, prefix)
+        @logger = logger
+        @prefix = prefix
+      end
+
+      def debug(msg)
+        @logger.debug("#{@prefix} #{msg}")
+      end
+
+      def info(msg)
+        @logger.info("#{@prefix} #{msg}")
+      end
+
+      def warn(msg)
+        @logger.warn("#{@prefix} #{msg}")
+      end
+
+      def error(msg)
+        @logger.error("#{@prefix} #{msg}")
+      end
+    end
+
+    module Logging
+      class << self
+        def logger
+          return @logger if @logger
+
+          base_logger = if defined?(Rails)
+                          Rails.logger
+                        else
+                          logger = Logger.new STDOUT
+                          logger.progname = 'Segment::Analytics'
+                          logger
+                        end
+          @logger = PrefixedLogger.new(base_logger, '[analytics-ruby]')
+        end
+
+        attr_writer :logger
+      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/message_batch.rb

@@ -0,0 +1,72 @@
+require 'forwardable'
+require 'segment/analytics/logging'
+
+module Segment
+  class Analytics
+    # A batch of `Message`s to be sent to the API
+    class MessageBatch
+      class JSONGenerationError < StandardError; end
+
+      extend Forwardable
+      include Segment::Analytics::Logging
+      include Segment::Analytics::Defaults::MessageBatch
+
+      def initialize(max_message_count)
+        @messages = []
+        @max_message_count = max_message_count
+        @json_size = 0
+      end
+
+      def <<(message)
+        begin
+          message_json = message.to_json
+        rescue StandardError => e
+          raise JSONGenerationError, "Serialization error: #{e}"
+        end
+
+        message_json_size = message_json.bytesize
+        if message_too_big?(message_json_size)
+          logger.error('a message exceeded the maximum allowed size')
+        else
+          @messages << message
+          @json_size += message_json_size + 1 # One byte for the comma
+        end
+      end
+
+      def full?
+        item_count_exhausted? || size_exhausted?
+      end
+
+      def clear
+        @messages.clear
+        @json_size = 0
+      end
+
+      def_delegators :@messages, :to_json
+      def_delegators :@messages, :empty?
+      def_delegators :@messages, :length
+
+      private
+
+      def item_count_exhausted?
+        @messages.length >= @max_message_count
+      end
+
+      def message_too_big?(message_json_size)
+        message_json_size > Defaults::Message::MAX_BYTES
+      end
+
+      # We consider the max size here as just enough to leave room for one more
+      # message of the largest size possible. This is a shortcut that allows us
+      # to use a native Ruby `Queue` that doesn't allow peeking. The tradeoff
+      # here is that we might fit in less messages than possible into a batch.
+      #
+      # The alternative is to use our own `Queue` implementation that allows
+      # peeking, and to consider the next message size when calculating whether
+      # the message can be accomodated in this batch.
+      def size_exhausted?
+        @json_size >= (MAX_BYTES - Defaults::Message::MAX_BYTES)
+      end
+    end
+  end
+end

data/lib/segment/analytics/request.rb

@@ -0,0 +1,135 @@
+require 'segment/analytics/defaults'
+require 'segment/analytics/utils'
+require 'segment/analytics/response'
+require 'segment/analytics/logging'
+require 'segment/analytics/backoff_policy'
+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
+        @headers = options[:headers] || HEADERS
+        @path = options[:path] || PATH
+        @retries = options[:retries] || RETRIES
+        @backoff_policy =
+          options[:backoff_policy] || Segment::Analytics::BackoffPolicy.new
+
+        uri = URI(options[:data_plane_url])
+        http = Net::HTTP.new(uri)
+        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)
+        logger.debug("Sending request for #{batch.length} items")
+
+        last_response, exception = retry_with_backoff(@retries) do
+          status_code, body = send_request(write_key, batch)
+          error = JSON.parse(body)['error']
+          should_retry = should_retry_request?(status_code, body)
+          logger.debug("Response status code: #{status_code}")
+          logger.debug("Response error: #{error}") if error
+
+          [Response.new(status_code, error), should_retry]
+        end
+
+        if exception
+          logger.error(exception.message)
+          exception.backtrace.each { |line| logger.error(line) }
+          Response.new(-1, exception.to_s)
+        else
+          last_response
+        end
+      end
+
+      private
+
+      def should_retry_request?(status_code, body)
+        if status_code >= 500
+          true # Server error
+        elsif status_code == 429
+          true # Rate limited
+        elsif status_code >= 400
+          logger.error(body)
+          false # Client error. Do not retry, but log
+        else
+          false
+        end
+      end
+
+      # Takes a block that returns [result, should_retry].
+      #
+      # Retries upto `retries_remaining` times, if `should_retry` is false or
+      # an exception is raised. `@backoff_policy` is used to determine the
+      # duration to sleep between attempts
+      #
+      # Returns [last_result, raised_exception]
+      def retry_with_backoff(retries_remaining, &block)
+        result, caught_exception = nil
+        should_retry = false
+
+        begin
+          result, should_retry = yield
+          return [result, nil] unless should_retry
+        rescue StandardError => e
+          should_retry = true
+          caught_exception = e
+        end
+
+        if should_retry && (retries_remaining > 1)
+          logger.debug("Retrying request, #{retries_remaining} retries left")
+          sleep(@backoff_policy.next_interval.to_f / 1000)
+          retry_with_backoff(retries_remaining - 1, &block)
+        else
+          [result, caught_exception]
+        end
+      end
+
+      # Sends a request for the batch, returns [status_code, body]
+      def send_request(write_key, batch)
+        payload = JSON.generate(
+          :sentAt => datetime_in_iso8601(Time.now),
+          :batch => batch
+        )
+        request = Net::HTTP::Post.new(@path, @headers)
+        request.basic_auth(write_key, nil)
+
+        if self.class.stub
+          logger.debug "stubbed request to #{@path}: " \
+            "write key = #{write_key}, batch = #{JSON.generate(batch)}"
+
+          [200, '{}']
+        else
+          response = @http.request(request, payload)
+          [response.code.to_i, response.body]
+        end
+      end
+
+      class << self
+        attr_writer :stub
+
+        def stub
+          @stub || ENV['STUB']
+        end
+      end
+    end
+  end
+end

data/lib/segment/analytics/response.rb

@@ -0,0 +1,15 @@
+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,91 @@
+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.each_with_object({}) do |(k, v), memo|
+          memo[k.to_sym] = v
+        end
+      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.each_with_object({}) do |(k, v), memo|
+          memo[k.to_s] = v
+        end
+      end
+
+      # public: Returns a new hash with all the date values in the into iso8601
+      #         strings
+      #
+      def isoify_dates(hash)
+        hash.each_with_object({}) do |(k, v), memo|
+          memo[k] = datetime_in_iso8601(v)
+        end
+      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 = '0.0.1'
+  end
+end

data/lib/segment/analytics/worker.rb

@@ -0,0 +1,67 @@
+require 'segment/analytics/defaults'
+require 'segment/analytics/message_batch'
+require 'segment/analytics/request'
+require 'segment/analytics/utils'
+
+module Segment
+  class Analytics
+    class Worker
+      include Segment::Analytics::Utils
+      include Segment::Analytics::Defaults
+      include Segment::Analytics::Logging
+
+      # 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, data_plane_url, write_key, options = {})
+        symbolize_keys! options
+        @queue = queue
+        @data_plane_url = data_plane_url
+        @write_key = write_key
+        @on_error = options[:on_error] || proc { |status, error| }
+        batch_size = options[:batch_size] || Defaults::MessageBatch::MAX_SIZE
+        @batch = MessageBatch.new(batch_size)
+        @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
+            consume_message_from_queue! until @batch.full? || @queue.empty?
+          end
+
+          res = Request.new(data_plane_url: @data_plane_url).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
+
+      private
+
+      def consume_message_from_queue!
+        @batch << @queue.pop
+      rescue MessageBatch::JSONGenerationError => e
+        @on_error.call(-1, e.to_s)
+      end
+    end
+  end
+end

data/lib/segment/analytics.rb

@@ -0,0 +1,39 @@
+require 'segment/analytics/version'
+require 'segment/analytics/defaults'
+require 'segment/analytics/utils'
+require 'segment/analytics/field_parser'
+require 'segment/analytics/client'
+require 'segment/analytics/worker'
+require 'segment/analytics/request'
+require 'segment/analytics/response'
+require 'segment/analytics/logging'
+
+module Segment
+  class Analytics
+    # Initializes a new instance of {Segment::Analytics::Client}, to which all
+    # method calls are proxied.
+    #
+    # @param options includes options that are passed down to
+    #   {Segment::Analytics::Client#initialize}
+    # @option options [Boolean] :stub (false) If true, requests don't hit the
+    #   server and are stubbed to be successful.
+    def initialize(options = {})
+      Request.stub = options[:stub] if options.has_key?(:stub)
+      @client = Segment::Analytics::Client.new options
+    end
+
+    def method_missing(message, *args, &block)
+      if @client.respond_to? message
+        @client.send message, *args, &block
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @client.respond_to?(method_name) || super
+    end
+
+    include Logging
+  end
+end

data/lib/segment.rb

@@ -0,0 +1 @@
+require 'segment/analytics'

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: ruddertest
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Rudder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.11
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.11
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.2
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+- !ruby/object:Gem::Dependency
+  name: codecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+description: The Rudder ruby analytics library
+email: sumanth@rudderlabs.com
+executables:
+- analytics
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/analytics
+- lib/analytics-ruby.rb
+- lib/segment.rb
+- lib/segment/analytics.rb
+- lib/segment/analytics/backoff_policy.rb
+- lib/segment/analytics/client.rb
+- lib/segment/analytics/defaults.rb
+- lib/segment/analytics/field_parser.rb
+- lib/segment/analytics/logging.rb
+- lib/segment/analytics/message_batch.rb
+- lib/segment/analytics/request.rb
+- lib/segment/analytics/response.rb
+- lib/segment/analytics/utils.rb
+- lib/segment/analytics/version.rb
+- lib/segment/analytics/worker.rb
+homepage: https://github.com/rudderlabs/analytics-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Rudder analytics library
+test_files: []